Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax > Class Template Reference

The concurrent_priority_queue class is a container that allows multiple threads to concurrently push and pop items. Items are popped in priority order where priority is determined by a functor supplied as a template argument. More...

#include <concurrent_priority_queue.h>

Classes
class	_Cpq_operation
class	_My_functor_type

Public Types
typedef _Ty	value_type
	A type that represents the data type stored in a concurrent priority queue. More...
typedef _Ty &	reference
	A type that represents a reference to an element of the type stored in a concurrent priority queue. More...
typedef const _Ty &	const_reference
	A type that represents a const reference to an element of the type stored in a concurrent priority queue. More...
typedef size_t	size_type
	A type that counts the number of elements in a concurrent priority queue. More...
typedef _Ax	allocator_type
	A type that represents the allocator class for the concurrent priority queue. More...

Public Member Functions
	concurrent_priority_queue (const allocator_type &_Al=allocator_type())
	Constructs a concurrent priority queue. More...
	concurrent_priority_queue (size_type _Init_capacity, const allocator_type &_Al=allocator_type())
	Constructs a concurrent priority queue. More...
template<typename _InputIterator >
	concurrent_priority_queue (_InputIterator _Begin, _InputIterator _End, const allocator_type &_Al=allocator_type())
	Constructs a concurrent priority queue. More...
	concurrent_priority_queue (const concurrent_priority_queue &_Src)
	Constructs a concurrent priority queue. More...
	concurrent_priority_queue (const concurrent_priority_queue &_Src, const allocator_type &_Al)
	Constructs a concurrent priority queue. More...
	concurrent_priority_queue (concurrent_priority_queue &&_Src)
	Constructs a concurrent priority queue. More...
	concurrent_priority_queue (concurrent_priority_queue &&_Src, const allocator_type &_Al)
	Constructs a concurrent priority queue. More...
concurrent_priority_queue &	operator= (const concurrent_priority_queue &_Src)
	Assigns the contents of another concurrent_priority_queue object to this one. This method is not concurrency-safe. More...
concurrent_priority_queue &	operator= (concurrent_priority_queue &&_Src)
	Assigns the contents of another concurrent_priority_queue object to this one. This method is not concurrency-safe. More...
bool	empty () const
	Tests if the concurrent priority queue is empty at the time this method is called. This method is concurrency-safe. More...
size_type	size () const
	Returns the number of elements in the concurrent priority queue. This method is concurrency-safe. More...
void	push (const value_type &_Elem)
	Adds an element to the concurrent priority queue. This method is concurrency-safe. More...
void	push (value_type &&_Elem)
	Adds an element to the concurrent priority queue. This method is concurrency-safe. More...
bool	try_pop (reference _Elem)
	Removes and returns the highest priority element from the queue if the queue is non-empty. This method is concurrency-safe. More...
void	clear ()
	Erases all elements in the concurrent priority. This method is not concurrency-safe. More...
void	swap (concurrent_priority_queue &_Queue)
	Swaps the contents of two concurrent priority queues. This method is not concurrency-safe. More...
allocator_type	get_allocator () const
	Returns a copy of the allocator used to construct the concurrent priority queue. This method is concurrency-safe. More...

Private Types
enum	_Operation_type { _INVALID_OP, _PUSH_OP_COPY, _PUSH_OP_MOVE, _POP_OP }
enum	_Operation_status { _WAIT =0, _SUCCEEDED, _FAILED }

Private Member Functions
void	_M_handle_operations (_Cpq_operation *_POp_list)
	Handle a batch of operations pending on the concurrent priority queue. Only one thread can execute this routine at a time. More...
void	_Heapify ()
	Merge unsorted elements into heap. More...
void	_Reheap ()
	Re-_Heapify by pushing last element down the heap from the root. More...

Private Attributes
::Concurrency::details::_Aggregator< _Cpq_operation, _My_functor_type >	_M_my_aggregator
char	_M_padding1 [64-sizeof(::Concurrency::details::_Aggregator< _Cpq_operation, _My_functor_type >)]
size_type	_M_mark
volatile size_type	_M_size
_Compare	_M_compare
char	_M_padding2 [64-sizeof(size_type)-sizeof(_Compare)]
std::vector< value_type, allocator_type >	_M_data

Detailed Description

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>
class Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >

The concurrent_priority_queue class is a container that allows multiple threads to concurrently push and pop items. Items are popped in priority order where priority is determined by a functor supplied as a template argument.

Template Parameters

_Ty	The data type of the elements to be stored in the priority queue.
_Compare	The type of the function object that can compare two element values as sort keys to determine their relative order in the priority queue. This argument is optional and the binary predicate less<_Ty > is the default value.
_Ax	The type that represents the stored allocator object that encapsulates details about the allocation and deallocation of memory for the concurrent priority queue. This argument is optional and the default value is allocator<_Ty >.

For detailed information on the concurrent_priority_queue class, see Parallel Containers and Objects.

See also

Parallel Containers and Objects

Member Typedef Documentation

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

typedef _Ax Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::allocator_type

A type that represents the allocator class for the concurrent priority queue.

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

typedef const _Ty& Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::const_reference

A type that represents a const reference to an element of the type stored in a concurrent priority queue.

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

typedef _Ty& Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::reference

A type that represents a reference to an element of the type stored in a concurrent priority queue.

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

typedef size_t Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::size_type

A type that counts the number of elements in a concurrent priority queue.

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

typedef _Ty Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::value_type

A type that represents the data type stored in a concurrent priority queue.

Member Enumeration Documentation

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

enum Concurrency::concurrent_priority_queue::_Operation_status

private

Enumerator
_WAIT
_SUCCEEDED
_FAILED

{ _WAIT=0, _SUCCEEDED, _FAILED };

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

enum Concurrency::concurrent_priority_queue::_Operation_type

private

Enumerator
_INVALID_OP
_PUSH_OP_COPY
_PUSH_OP_MOVE
_POP_OP

{_INVALID_OP, _PUSH_OP_COPY, _PUSH_OP_MOVE, _POP_OP};

Constructor & Destructor Documentation

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::concurrent_priority_queue ( const allocator_type &  _Al = allocator_type() )

inlineexplicit

Constructs a concurrent priority queue.

Parameters

_Al	The allocator class to use with this object.

All constructors store an allocator object _Al and initialize the priority queue.

The first constructor specifies an empty initial priority queue and optionally specifies an allocator.

The second constructor specifies a priority queue with an initial capacity _Init_capacity and optionally specifies an allocator.

The third constructor specifies values supplied by the iterator range [_Begin , _End ) and optionally specifies an allocator.

The fourth and fifth constructors specify a copy of the priority queue _Src .

The sixth and seventh constructors specify a move of the priority queue _Src .

                                                                                     : _M_mark(0), _M_size(0), _M_data(_Al)
    {
        _M_my_aggregator._Initialize_handler(_My_functor_type(this));
    }

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::concurrent_priority_queue ( size_type  _Init_capacity, const allocator_type &  _Al = allocator_type()  )

inlineexplicit

Constructs a concurrent priority queue.

Parameters

_Init_capacity	The initial capacity of the concurrent_priority_queue object.
_Al	The allocator class to use with this object.

All constructors store an allocator object _Al and initialize the priority queue.

The first constructor specifies an empty initial priority queue and optionally specifies an allocator.

The second constructor specifies a priority queue with an initial capacity _Init_capacity and optionally specifies an allocator.

The third constructor specifies values supplied by the iterator range [_Begin , _End ) and optionally specifies an allocator.

The fourth and fifth constructors specify a copy of the priority queue _Src .

The sixth and seventh constructors specify a move of the priority queue _Src .

                                                                                                               : _M_mark(0), _M_size(0), _M_data(_Al)
    {
        _M_data.reserve(_Init_capacity);
        _M_my_aggregator._Initialize_handler(_My_functor_type(this));
    }

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

template<typename _InputIterator >

Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::concurrent_priority_queue ( _InputIterator  _Begin, _InputIterator  _End, const allocator_type &  _Al = allocator_type()  )

inline

Constructs a concurrent priority queue.

Template Parameters

_InputIterator

The type of the input iterator.

Parameters

_Begin	The position of the first element in the range of elements to be copied.
_End	The position of the first element beyond the range of elements to be copied.
_Al	The allocator class to use with this object.

All constructors store an allocator object _Al and initialize the priority queue.

The first constructor specifies an empty initial priority queue and optionally specifies an allocator.

The second constructor specifies a priority queue with an initial capacity _Init_capacity and optionally specifies an allocator.

The third constructor specifies values supplied by the iterator range [_Begin , _End ) and optionally specifies an allocator.

The fourth and fifth constructors specify a copy of the priority queue _Src .

The sixth and seventh constructors specify a move of the priority queue _Src .

                                                                                                                        : _M_data(_Begin, _End, _Al)
    {
        // Set the mark to 0 to indicate that nothing is sorted.
        _M_mark = 0;
        _M_size = _M_data.size();
        _M_my_aggregator._Initialize_handler(_My_functor_type(this));
        _Heapify();
    }

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::concurrent_priority_queue ( const concurrent_priority_queue< _Ty, _Compare, _Ax > &  _Src )

inline

Constructs a concurrent priority queue.

Parameters

_Src	The source concurrent_priority_queue object to copy or move elements from.

All constructors store an allocator object _Al and initialize the priority queue.

The first constructor specifies an empty initial priority queue and optionally specifies an allocator.

The second constructor specifies a priority queue with an initial capacity _Init_capacity and optionally specifies an allocator.

The third constructor specifies values supplied by the iterator range [_Begin , _End ) and optionally specifies an allocator.

The fourth and fifth constructors specify a copy of the priority queue _Src .

The sixth and seventh constructors specify a move of the priority queue _Src .

                                                                     : _M_mark(_Src._M_mark), _M_size(_Src._M_size), _M_data(_Src._M_data)
    {
        _M_my_aggregator._Initialize_handler(_My_functor_type(this));
        _Heapify();
    }

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::concurrent_priority_queue ( const concurrent_priority_queue< _Ty, _Compare, _Ax > &  _Src, const allocator_type &  _Al  )

inline

Constructs a concurrent priority queue.

Parameters

_Src	The source concurrent_priority_queue object to copy or move elements from.
_Al	The allocator class to use with this object.

All constructors store an allocator object _Al and initialize the priority queue.

The first constructor specifies an empty initial priority queue and optionally specifies an allocator.

The second constructor specifies a priority queue with an initial capacity _Init_capacity and optionally specifies an allocator.

The third constructor specifies values supplied by the iterator range [_Begin , _End ) and optionally specifies an allocator.

The fourth and fifth constructors specify a copy of the priority queue _Src .

The sixth and seventh constructors specify a move of the priority queue _Src .

                                                                                                : _M_mark(_Src._M_mark), _M_data(_Src._M_data.begin(), _Src._M_data.end(), _Al)
    {
        _M_size = _M_data.size();
        _M_my_aggregator._Initialize_handler(_My_functor_type(this));
        _Heapify();
    }

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::concurrent_priority_queue ( concurrent_priority_queue< _Ty, _Compare, _Ax > &&  _Src )

inline

Constructs a concurrent priority queue.

Parameters

_Src	The source concurrent_priority_queue object to copy or move elements from.

All constructors store an allocator object _Al and initialize the priority queue.

The first constructor specifies an empty initial priority queue and optionally specifies an allocator.

The second constructor specifies a priority queue with an initial capacity _Init_capacity and optionally specifies an allocator.

The third constructor specifies values supplied by the iterator range [_Begin , _End ) and optionally specifies an allocator.

The fourth and fifth constructors specify a copy of the priority queue _Src .

The sixth and seventh constructors specify a move of the priority queue _Src .

                                                                : _M_mark(_Src._M_mark), _M_size(_Src._M_size), _M_data(std::move(_Src._M_data))
    {
        // Set _M_mark and _M_size for the argument to 0 because its data has been moved over to this priority queue.
        _Src._M_mark = 0;
        _Src._M_size = 0;
        _M_my_aggregator._Initialize_handler(_My_functor_type(this));
        _Heapify();
    }

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::concurrent_priority_queue ( concurrent_priority_queue< _Ty, _Compare, _Ax > &&  _Src, const allocator_type &  _Al  )

inline

Constructs a concurrent priority queue.

Parameters

_Src	The source concurrent_priority_queue object to copy or move elements from.
_Al	The allocator class to use with this object.

All constructors store an allocator object _Al and initialize the priority queue.

The first constructor specifies an empty initial priority queue and optionally specifies an allocator.

The second constructor specifies a priority queue with an initial capacity _Init_capacity and optionally specifies an allocator.

The third constructor specifies values supplied by the iterator range [_Begin , _End ) and optionally specifies an allocator.

The fourth and fifth constructors specify a copy of the priority queue _Src .

The sixth and seventh constructors specify a move of the priority queue _Src .

                                                                                           : _M_mark(_Src._M_mark), _M_size(_Src._M_size), _M_data(std::move(_Src._M_data), _Al)
    {
        // Set _M_mark and _M_size for the argument to 0 because its data has been moved over to this priority queue.
        _Src._M_mark = 0;
        _Src._M_size = 0;
        _M_my_aggregator._Initialize_handler(_My_functor_type(this));
        _Heapify();
    }

Member Function Documentation

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

void Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::_Heapify ( )

inlineprivate

Merge unsorted elements into heap.

    {
        if (_M_mark == 0 && _M_size > 0)
        {
            _M_mark = 1;
        }

        for (; _M_mark < _M_size; ++_M_mark)
        {
            // for each unheapified element under size
            size_type _Cur_pos = _M_mark;
            value_type _To_place = std::move(_M_data[_M_mark]);
            do
            { // push _To_place up the heap
                size_type _Parent = (_Cur_pos - 1) >> 1;
                if (!_M_compare(_M_data[_Parent], _To_place))
                {
                    break;
                }
                _M_data[_Cur_pos] = std::move(_M_data[_Parent]);
                _Cur_pos = _Parent;

            } while( _Cur_pos != 0 );

            _M_data[_Cur_pos] = std::move(_To_place);
        }
    }

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

void Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::_M_handle_operations ( _Cpq_operation *  _POp_list )

inlineprivate

Handle a batch of operations pending on the concurrent priority queue. Only one thread can execute this routine at a time.

    {
        _Cpq_operation *_PTmp, *_PPop_list=NULL;

        _CONCRT_ASSERT(_M_mark == _M_data.size());

        // First pass processes all constant time operations: pushes, some pops.
        while (_POp_list != NULL)
        {
            _CONCRT_ASSERT(_POp_list->_M_type != _INVALID_OP);
            _PTmp = _POp_list;
            _POp_list = _POp_list->_M_pNext;
            if (_PTmp->_M_type == _PUSH_OP_COPY)
            {
                try
                {
                    _M_data.push_back(*(_PTmp->_M_elem));
                    ++_M_size;
                    _InterlockedExchange((volatile long *) &_PTmp->_M_status, _SUCCEEDED);
                }
                catch (...)
                {
                    _PTmp->_M_exception_ptr = std::current_exception();
                    _InterlockedExchange((volatile long *) &_PTmp->_M_status, _FAILED);
                }
            }
            else if (_PTmp->_M_type == _PUSH_OP_MOVE)
            {
                try
                {
                    _M_data.push_back(std::move(*(_PTmp->_M_elem)));
                    ++_M_size;
                    _InterlockedExchange((volatile long *) &_PTmp->_M_status, _SUCCEEDED);
                }
                catch (...)
                {
                    _PTmp->_M_exception_ptr = std::current_exception();
                    _InterlockedExchange((volatile long *) &_PTmp->_M_status, _FAILED);
                }
            }
            else
            {
                _CONCRT_ASSERT(_PTmp->_M_type == _POP_OP);
                if (_M_mark < _M_size && _M_compare(_M_data[0], _M_data[_M_size - 1]))
                {
                    // There are newly pushed elems and the last one is higher than top
                    // Because we're going to pop the last element, we can move the _M_data instead of copying it.
                    *(_PTmp->_M_elem) = std::move(_M_data[_M_size - 1]);
                    --_M_size;
                    _InterlockedExchange((volatile long *) &_PTmp->_M_status, _SUCCEEDED);
                    _M_data.pop_back();

                    _CONCRT_ASSERT(_M_mark <= _M_size);
                }
                else
                {
                    // No convenient item to pop; postpone
                    _PTmp->_M_pNext = _PPop_list;
                    _PPop_list = _PTmp;
                }
            }
        }

        // Second pass processes pop operations.
        while (_PPop_list != NULL)
        {
            _PTmp = _PPop_list;
            _PPop_list = _PPop_list->_M_pNext;
            _CONCRT_ASSERT(_PTmp->_M_type == _POP_OP);

            if (_M_size == 0)
            {
                _InterlockedExchange((volatile long *) &_PTmp->_M_status, _FAILED);
            }
            else
            {
                _CONCRT_ASSERT(_M_mark <= _M_size);

                if (_M_mark < _M_size && _M_compare(_M_data[0], _M_data[_M_size - 1]))
                {
                    // There are newly pushed elems and the last one is higher than top.
                    // Because we're going to pop the last element, we can move the _M_data instead of copying it.
                    *(_PTmp->_M_elem) = std::move(_M_data[_M_size - 1]); // copy the _M_data
                    --_M_size;
                    _InterlockedExchange((volatile long *) &_PTmp->_M_status, _SUCCEEDED);
                    _M_data.pop_back();
                }
                else
                {
                    // Extract top and push last element down heap.
                    *(_PTmp->_M_elem) = std::move(_M_data[0]); // copy the _M_data
                    --_M_size;
                    _InterlockedExchange((volatile long *) &_PTmp->_M_status, _SUCCEEDED);
                    _Reheap();
                }
            }
        }
        _CONCRT_ASSERT(_M_size == _M_data.size());
        // _Heapify any leftover pushed elements before doing the next batch of operations.
        if (_M_mark < _M_size)
        {
            _Heapify();
        }
        _CONCRT_ASSERT(_M_mark == _M_size);
    }

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

void Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::_Reheap ( )

inlineprivate

Re-_Heapify by pushing last element down the heap from the root.

    {
        size_type _Cur_pos=0, _Child=1;
        // Use _M_data.size() instead of _M_size throughout this function, because _M_size has already
        // been decremented to account for the pop right before Reheap was invoked.
        while (_Child < _M_mark)
        {
            size_type _Target = _Child;
            if (_Child + 1 < _M_mark && _M_compare(_M_data[_Child], _M_data[_Child + 1]))
            {
                ++_Target;
            }
            // _Target now has the higher priority _Child.
            if (_M_compare(_M_data[_Target], _M_data[_M_data.size() - 1]))
            {
                break;
            }

            _M_data[_Cur_pos] = std::move(_M_data[_Target]);
            _Cur_pos = _Target;
            _Child = (_Cur_pos << 1) + 1;
        }

        _M_data[_Cur_pos] = std::move(_M_data[_M_data.size() - 1]);
        _M_data.pop_back();

        if (_M_mark > _M_data.size())
        {
            _M_mark = _M_data.size();
        }
    }

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

void Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::clear ( )

inline

Erases all elements in the concurrent priority. This method is not concurrency-safe.

clear is not concurrency-safe. You must ensure that no other threads are invoking methods on the concurrent priority queue when you call this method. clear does not free memory.

    {
        _M_data.clear();
        _M_mark = 0;
        _M_size = 0;
    }

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

bool Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::empty ( ) const

inline

Tests if the concurrent priority queue is empty at the time this method is called. This method is concurrency-safe.

Returns

true if the priority queue was empty at the moment the function was called, false otherwise.

    {
        return (_M_size == 0);
    }

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

allocator_type Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::get_allocator ( ) const

inline

Returns a copy of the allocator used to construct the concurrent priority queue. This method is concurrency-safe.

Returns

A copy of the allocator used to construct the concurrent_priority_queue object.

{ return _M_data.get_allocator(); }

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

concurrent_priority_queue& Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::operator= ( const concurrent_priority_queue< _Ty, _Compare, _Ax > &  _Src )

inline

Assigns the contents of another concurrent_priority_queue object to this one. This method is not concurrency-safe.

Parameters

_Src	The source concurrent_priority_queue object.

Returns

A reference to this concurrent_priority_queue object.

    {
        if (this != &_Src)
        {
            std::vector<value_type, allocator_type>(_Src._M_data.begin(), _Src._M_data.end(), _Src._M_data.get_allocator()).swap(_M_data);
            _M_mark = _Src._M_mark;
            _M_size = _Src._M_size;
        }
        return *this;
    }

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

concurrent_priority_queue& Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::operator= ( concurrent_priority_queue< _Ty, _Compare, _Ax > &&  _Src )

inline

Assigns the contents of another concurrent_priority_queue object to this one. This method is not concurrency-safe.

Parameters

_Src	The source concurrent_priority_queue object.

Returns

A reference to this concurrent_priority_queue object.

    {
        if (this != &_Src)
        {
            _M_data = std::move(_Src._M_data);
            _M_mark = _Src._M_mark;
            _M_size = _Src._M_size;
            // Set _M_mark and _M_size for the arguement to 0 because its data has been moved over to this priority queue.
            _Src._M_mark = 0;
            _Src._M_size = 0;
        }
        return *this;
    }

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

void Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::push ( const value_type &  _Elem )

inline

Adds an element to the concurrent priority queue. This method is concurrency-safe.

Parameters

_Elem

The element to be added to the concurrent priority queue.

    {
        _Cpq_operation _Op_data(_Elem, _PUSH_OP_COPY);
        _M_my_aggregator._Execute(&_Op_data);
        if (_Op_data._M_status == _FAILED)
        {
            // Rethrow the saved exception.
            std::rethrow_exception(_Op_data._M_exception_ptr);
        }
    }

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

void Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::push ( value_type &&  _Elem )

inline

Adds an element to the concurrent priority queue. This method is concurrency-safe.

Parameters

_Elem

The element to be added to the concurrent priority queue.

    {
        _Cpq_operation _Op_data(_Elem, _PUSH_OP_MOVE);
        _M_my_aggregator._Execute(&_Op_data);
        if (_Op_data._M_status == _FAILED)
        {
            // Rethrow the saved exception
            std::rethrow_exception(_Op_data._M_exception_ptr);
        }
    }

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

size_type Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::size ( ) const

inline

Returns the number of elements in the concurrent priority queue. This method is concurrency-safe.

Returns

The number of elements in this concurrent_priority_queue object.

The returned size is guaranteed to include all elements added by calls to the function push. However, it may not reflect results of pending concurrent operations.

    {
        return _M_size;
    }

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

void Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::swap ( concurrent_priority_queue< _Ty, _Compare, _Ax > &  _Queue )

inline

Swaps the contents of two concurrent priority queues. This method is not concurrency-safe.

Parameters

_Queue

The concurrent_priority_queue object to swap contents with.

    {
        _M_data.swap(_Queue._M_data);
        std::swap(_M_mark, _Queue._M_mark);
        std::swap(_M_size, _Queue._M_size);
    }

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

bool Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::try_pop ( reference  _Elem )

inline

Removes and returns the highest priority element from the queue if the queue is non-empty. This method is concurrency-safe.

Parameters

_Elem

A reference to a variable that will be populated with the highest priority element, if the queue is non-empty.

Returns

true if a value was popped, false otherwise.

    {
        _Cpq_operation _Op_data(_POP_OP);
        _Op_data._M_elem = &_Elem;
        _M_my_aggregator._Execute(&_Op_data);
        return (_Op_data._M_status == _SUCCEEDED);
    }

Member Data Documentation

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

_Compare Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::_M_compare

private

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

std::vector<value_type, allocator_type> Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::_M_data

private

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

size_type Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::_M_mark

private

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

::Concurrency::details::_Aggregator< _Cpq_operation, _My_functor_type > Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::_M_my_aggregator

private

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

char Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::_M_padding1[64-sizeof(::Concurrency::details::_Aggregator< _Cpq_operation, _My_functor_type >)]

private

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

char Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::_M_padding2[64-sizeof(size_type)-sizeof(_Compare)]

private

template<typename _Ty, typename _Compare = std::less<_Ty>, typename _Ax = std::allocator<_Ty>>

volatile size_type Concurrency::concurrent_priority_queue< _Ty, _Compare, _Ax >::_M_size

private

---

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

• VS2015/inc/concurrent_priority_queue.h