LockedQueue< T, StorageType > Class Template Reference

#include <LockedQueue.h>

Public Member Functions
	LockedQueue ()
	Create a LockedQueue. More...
virtual	~LockedQueue ()
	Destroy a LockedQueue. More...
void	add (const T &item)
	Adds an item to the queue. More...
template<class Iterator >
void	readd (Iterator begin, Iterator end)
	Adds items back to front of the queue. More...
bool	next (T &result)
	Gets the next result in the queue, if any. More...
template<class Checker >
bool	next (T &result, Checker &check)
T &	peek (bool autoUnlock=false)
	Peeks at the top of the queue. Check if the queue is empty before calling! Remember to unlock after use if autoUnlock == false. More...
void	cancel ()
	Cancels the queue. More...
bool	cancelled ()
	Checks if the queue is cancelled. More...
void	lock ()
	Locks the queue for access. More...
void	unlock ()
	Unlocks the queue. More...
void	pop_front ()
	! Calls pop_front of the queue More...
bool	empty ()
	! Checks if we're empty or not with locks held More...

Private Attributes
std::mutex	_lock
	Lock access to the queue. More...
StorageType	_queue
	Storage backing the queue. More...
volatile bool	_canceled
	Cancellation flag. More...

Constructor & Destructor Documentation

template<class T, typename StorageType = std::deque<T>>

LockedQueue< T, StorageType >::LockedQueue ( )

inline

Create a LockedQueue.

 : _canceled(false)
 {
 }

template<class T, typename StorageType = std::deque<T>>

virtual LockedQueue< T, StorageType >::~LockedQueue ( )

inlinevirtual

Destroy a LockedQueue.

 {
 }

Member Function Documentation

template<class T, typename StorageType = std::deque<T>>

void LockedQueue< T, StorageType >::add ( const T &  item )

inline

Adds an item to the queue.

 {
 lock();

 _queue.push_back(item);

 unlock();
 }

Here is the caller graph for this function:

template<class T, typename StorageType = std::deque<T>>

void LockedQueue< T, StorageType >::cancel ( )

inline

Cancels the queue.

 {
 std::lock_guard<std::mutex> lock(_lock);

 _canceled = true;
 }

template<class T, typename StorageType = std::deque<T>>

bool LockedQueue< T, StorageType >::cancelled ( )

inline

Checks if the queue is cancelled.

 {
 std::lock_guard<std::mutex> lock(_lock);
 return _canceled;
 }

template<class T, typename StorageType = std::deque<T>>

bool LockedQueue< T, StorageType >::empty ( )

inline

! Checks if we're empty or not with locks held

 {
 std::lock_guard<std::mutex> lock(_lock);
 return _queue.empty();
 }

template<class T, typename StorageType = std::deque<T>>

void LockedQueue< T, StorageType >::lock ( )

inline

Locks the queue for access.

 {
 this->_lock.lock();
 }

Here is the caller graph for this function:

template<class T, typename StorageType = std::deque<T>>

bool LockedQueue< T, StorageType >::next ( T &  result )

inline

Gets the next result in the queue, if any.

 {
 std::lock_guard<std::mutex> lock(_lock);

 if (_queue.empty())
 return false;

 result = _queue.front();
 _queue.pop_front();

 return true;
 }

Here is the caller graph for this function:

template<class T, typename StorageType = std::deque<T>>

template<class Checker >

bool LockedQueue< T, StorageType >::next ( T &  result, Checker &  check  )

inline

 {
 std::lock_guard<std::mutex> lock(_lock);

 if (_queue.empty())
 return false;

 result = _queue.front();
 if (!check.Process(result))
 return false;

 _queue.pop_front();
 return true;
 }

template<class T, typename StorageType = std::deque<T>>

T& LockedQueue< T, StorageType >::peek ( bool  autoUnlock = false )

inline

Peeks at the top of the queue. Check if the queue is empty before calling! Remember to unlock after use if autoUnlock == false.

 {
 lock();

 T& result = _queue.front();

 if (autoUnlock)
 unlock();

 return result;
 }

template<class T, typename StorageType = std::deque<T>>

void LockedQueue< T, StorageType >::pop_front ( )

inline

! Calls pop_front of the queue

 {
 std::lock_guard<std::mutex> lock(_lock);
 _queue.pop_front();
 }

template<class T, typename StorageType = std::deque<T>>

template<class Iterator >

void LockedQueue< T, StorageType >::readd ( Iterator  begin, Iterator  end  )

inline

Adds items back to front of the queue.

 {
 std::lock_guard<std::mutex> lock(_lock);
 _queue.insert(_queue.begin(), begin, end);
 }

Here is the caller graph for this function:

template<class T, typename StorageType = std::deque<T>>

void LockedQueue< T, StorageType >::unlock ( )

inline

Unlocks the queue.

 {
 this->_lock.unlock();
 }

Here is the caller graph for this function:

Member Data Documentation

template<class T, typename StorageType = std::deque<T>>

volatile bool LockedQueue< T, StorageType >::_canceled

private

Cancellation flag.

template<class T, typename StorageType = std::deque<T>>

std::mutex LockedQueue< T, StorageType >::_lock

private

Lock access to the queue.

template<class T, typename StorageType = std::deque<T>>

StorageType LockedQueue< T, StorageType >::_queue

private

Storage backing the queue.

---

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

• src/common/Threading/LockedQueue.h