locklessQueue.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file locklessQueue.h
//! \brief Defines a thread-safe queue for single reader/single writer scenarios
//! \ingroup vreRadarFxShared
 
#pragma once
 
#include <vector>
 
namespace makRadarFx
{
//! \brief Thread-safe queue for single reader/single writer communication
//! \tparam T Type of elements stored in the queue
//!
//! This template class provides a thread-safe queue designed for transferring data
//! between a single producer thread and a single consumer thread without requiring
//! locks. The implementation may block if the queue fills up, providing
//! backpressure to prevent overflow. This queue is optimized for performance in
//! inter-thread communication scenarios.
template <class T>
class DtLocklessQueue
{
public:
   //! \brief Constructor with specified queue capacity
   //! \param size Maximum number of elements that can be stored in the queue
   //!
   //! Creates a new lockless queue with the specified capacity
   DtLocklessQueue(int size);
 
   //! \brief Destructor
   //!
   //! Cleans up and releases all queue resources
   ~DtLocklessQueue();
 
   //! \brief Adds an element to the queue
   //! \param newElement Element to add to the queue
   //!
   //! Adds an element to the queue. If the queue is full, this method will
   //! block until space becomes available. This method is safe to call
   //! from a single producer thread.
   void push(T newElement);
 
   //! \brief Removes and returns an element from the queue
   //! \return The next element from the queue
   //!
   //! Removes and returns the next element from the queue. If the queue is empty,
   //! this method will block until data becomes available. This method is safe
   //! to call from a single consumer thread.
   T pop();
 
   //! \brief Checks if there is room to add an element without blocking
   //! \return True if push() can be called without blocking, false otherwise
   //!
   //! This method checks if the queue has space available for adding an element.
   //! If this returns false, a call to push() will block until space is available.
   bool okToPush();
 
   //! \brief Gets the current number of elements in the queue
   //! \return Number of elements currently in the queue
   //!
   //! Returns the number of elements currently stored in the queue.
   //! This is thread-safe but may not be atomically consistent with other operations.
   int count();
 
private:
   //! \brief Default constructor
   //!
   //! Intentionally unimplemented to prevent usage
   DtLocklessQueue();
 
   //! \brief Copy constructor
   //! \param orig Queue to copy from
   //!
   //! Intentionally unimplemented to prevent copying
   DtLocklessQueue(const DtLocklessQueue& orig);
 
   //! \brief Assignment operator
   //! \param rhs Queue to assign from
   //! \return Reference to this queue
   //!
   //! Intentionally unimplemented to prevent assignment
   DtLocklessQueue& operator=(const DtLocklessQueue& rhs);
 
protected:
   //! \brief Storage for queue elements
   std::vector<T> myElements;
 
   //! \brief Index of the next element to read
   //! Value of -1 indicates the queue is empty
   int myReadHead;
 
   //! \brief Index where the next element will be written
   int myWriteHead;
};
} // namespace makRadarFx
 
#define DtLocklessQueue_INL_
#include "locklessQueue.inl"
#undef DtLocklessQueue_INL_