Concurrency::details::_Queue< _Message > Class Template Reference

#include <agents.h>

Inheritance diagram for Concurrency::details::_Queue< _Message >:

Public Types
typedef _Message	type

Public Member Functions
	_Queue ()
	~_Queue ()
size_t	_Count () const
bool	_Enqueue (_Message *_Element)
bool	_Remove (_Message *_OldElement)
_Message *	_Dequeue ()
_Message *	_Peek ()
bool	_Is_head (runtime_object_identity _MsgId)
Public Member Functions inherited from Concurrency::details::_AllocBase
void *	operator new (size_t _Size)
void	operator delete (void *_Ptr) throw ()
void *	operator new (size_t _Size, const std::nothrow_t &) throw ()
void	operator delete (void *_Ptr, const std::nothrow_t &) throw ()
void *	operator new[] (size_t _Size)
void	operator delete[] (void *_Ptr) throw ()
void *	operator new[] (size_t _Size, const std::nothrow_t &_No_throw) throw ()
void	operator delete[] (void *_Ptr, const std::nothrow_t &_No_throw) throw ()
void *	operator new (size_t, void *_Location) throw ()
void	operator delete (void *, void *) throw ()
void *__cdecl	operator new[] (size_t, void *_Location) throw ()
void __cdecl	operator delete[] (void *, void *) throw ()

Protected Attributes
_Message *	_M_pHead
_Message **	_M_ppTail
size_t	_M_count

Member Typedef Documentation

template<class _Message>

typedef _Message Concurrency::details::_Queue< _Message >::type

Constructor & Destructor Documentation

template<class _Message>

Concurrency::details::_Queue< _Message >::_Queue ( )

inline

                 : _M_pHead(NULL), _M_ppTail(&_M_pHead), _M_count(0)
        {
        }

template<class _Message>

Concurrency::details::_Queue< _Message >::~_Queue ( )

inline

        {
        }

Member Function Documentation

template<class _Message>

size_t Concurrency::details::_Queue< _Message >::_Count ( ) const

inline

        {
            return _M_count;
        }

template<class _Message>

_Message* Concurrency::details::_Queue< _Message >::_Dequeue ( )

inline

        {
            if (_M_pHead == NULL)
            {
                return NULL;
            }

            _Message * _Result = _M_pHead;

            _M_pHead = _Result->_M_pNext;
            if (_M_pHead == NULL)
            {
                _M_ppTail = &_M_pHead;
            }

            _Result->_M_pNext = NULL;
            _M_count--;
            return _Result;
        }

template<class _Message>

bool Concurrency::details::_Queue< _Message >::_Enqueue ( _Message *  _Element )

inline

        {
            _CONCRT_ASSERT(_Element->_M_pNext == NULL);
            _CONCRT_ASSERT(*_M_ppTail == NULL);

            *_M_ppTail = _Element;
            _Element->_M_pNext = NULL;
            _M_ppTail = &(_Element->_M_pNext);
            _M_count++;

            return true;
        }

template<class _Message>

bool Concurrency::details::_Queue< _Message >::_Is_head ( runtime_object_identity  _MsgId )

inline

        {
            // Peek at the next message in the message buffer.  Use it to
            // check if the IDs match
            _Message * _Msg = _M_pHead;

            if (_Msg == NULL || _Msg->msg_id() != _MsgId)
            {
                return false;
            }

            return true;
        }

template<class _Message>

_Message* Concurrency::details::_Queue< _Message >::_Peek ( )

inline

        {
            return _M_pHead;
        }

template<class _Message>

bool Concurrency::details::_Queue< _Message >::_Remove ( _Message *  _OldElement )

inline

        {
            bool _Result = false;

            _CONCRT_ASSERT(_OldElement != NULL);

            if (_M_pHead == _OldElement)
            {
                _M_pHead = _OldElement->_M_pNext;
                if (_M_pHead == NULL)
                {
                    _M_ppTail = &_M_pHead;
                }

                _OldElement->_M_pNext = NULL;
                _M_count--;
                _Result = true;
            }
            else
            {
                _Message * _Next = NULL;
                for (_Message * _Node = _M_pHead; _Node != NULL; _Node = _Next)
                {
                    _Next = _Node->_M_pNext;

                    if (_Node->_M_pNext == _OldElement)
                    {
                        _Node->_M_pNext = _OldElement->_M_pNext;
                        // if this is the last element of the _Queue
                        if (_Node->_M_pNext == NULL && _M_count == 1)
                        {
                            _M_ppTail = &_M_pHead;
                        }

                        _OldElement->_M_pNext = NULL;
                        _M_count--;
                        _Result = true;
                        break;
                    }
                }
            }

            return _Result;
        }

Member Data Documentation

template<class _Message>

size_t Concurrency::details::_Queue< _Message >::_M_count

protected

template<class _Message>

_Message* Concurrency::details::_Queue< _Message >::_M_pHead

protected

template<class _Message>

_Message** Concurrency::details::_Queue< _Message >::_M_ppTail

protected

---

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

• VS2013/inc/agents.h