circularbuffer.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef CIRCULARBUFFER_H
#define CIRCULARBUFFER_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "../utils_global.h"
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QPair>
#include <QSemaphore>
#include <QSharedPointer>
 
//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================
 
#include <Eigen/Core>
 
//=============================================================================================================
// DEFINE NAMESPACE UTILSLIB
//=============================================================================================================
 
namespace UTILSLIB
{
 
//=============================================================================================================
template<typename T>
class CircularBuffer
{
public:
    typedef QSharedPointer<CircularBuffer> SPtr;            
    typedef QSharedPointer<const CircularBuffer> ConstSPtr; 
 
    //=========================================================================================================
    explicit CircularBuffer(unsigned int uiMaxNumElements);
 
    //=========================================================================================================
    ~CircularBuffer();
 
    //=========================================================================================================
    inline bool push(const T* pArray, unsigned int size);
 
    //=========================================================================================================
    inline bool push(const T& newElement);
 
    //=========================================================================================================
    inline bool pop(T& element);
 
    //=========================================================================================================
    void clear();
 
    //=========================================================================================================
    inline void pause(bool);
 
    //=========================================================================================================
    inline int getFreeElementsRead();
 
    //=========================================================================================================
    inline int getFreeElementsWrite();
 
private:
    //=========================================================================================================
    inline unsigned int mapIndex(int& index);
    unsigned int m_uiMaxNumElements; 
    T* m_pBuffer;                    
    int m_iCurrentReadIndex;         
    int m_iCurrentWriteIndex;        
    QSemaphore* m_pFreeElements;     
    QSemaphore* m_pUsedElements;     
    int m_iTimeout;                  
 
    bool m_bPause;
};
 
//=============================================================================================================
// DEFINE MEMBER METHODS
//=============================================================================================================
 
template<typename T>
CircularBuffer<T>::CircularBuffer(unsigned int uiMaxNumElements)
: m_uiMaxNumElements(uiMaxNumElements)
, m_pBuffer(new T[m_uiMaxNumElements])
, m_iCurrentReadIndex(-1)
, m_iCurrentWriteIndex(-1)
, m_pFreeElements(new QSemaphore(m_uiMaxNumElements))
, m_pUsedElements(new QSemaphore(0))
, m_iTimeout(1000)
, m_bPause(false)
{
}
 
//=============================================================================================================
 
template<typename T>
CircularBuffer<T>::~CircularBuffer()
{
    delete m_pFreeElements;
    delete m_pUsedElements;
    delete[] m_pBuffer;
}
 
//=============================================================================================================
 
template<typename T>
inline bool CircularBuffer<T>::push(const T* pArray, unsigned int size)
{
    if (m_bPause) {
        return false;
    }
 
    if (m_pFreeElements->tryAcquire(size, m_iTimeout)) {
        for (unsigned int i = 0; i < size; ++i) {
            m_pBuffer[mapIndex(m_iCurrentWriteIndex)] = pArray[i];
        }
        const QSemaphoreReleaser releaser(m_pUsedElements, size);
    } else {
        return false;
    }
 
    return true;
}
 
//=============================================================================================================
 
template<typename T>
inline bool CircularBuffer<T>::push(const T& newElement)
{
    if (m_bPause) {
        return false;
    }
 
    if (m_pFreeElements->tryAcquire(1, m_iTimeout)) {
        m_pBuffer[mapIndex(m_iCurrentWriteIndex)] = newElement;
        const QSemaphoreReleaser releaser(m_pUsedElements, 1);
    } else {
        return false;
    }
 
    return true;
}
 
//=============================================================================================================
 
template<typename T>
inline bool CircularBuffer<T>::pop(T& element)
{
    if (m_bPause) {
        return false;
    }
 
    if (m_pUsedElements->tryAcquire(1, m_iTimeout)) {
        element = m_pBuffer[mapIndex(m_iCurrentReadIndex)];
        const QSemaphoreReleaser releaser(m_pFreeElements, 1);
    } else {
        return false;
    }
 
    return true;
}
 
//=============================================================================================================
 
template<typename T>
inline unsigned int CircularBuffer<T>::mapIndex(int& index)
{
    int aux = index;
    return index = ++aux % m_uiMaxNumElements;
}
 
//=============================================================================================================
 
template<typename T>
inline void CircularBuffer<T>::clear()
{
    delete m_pFreeElements;
    m_pFreeElements = new QSemaphore(m_uiMaxNumElements);
    delete m_pUsedElements;
    m_pUsedElements = new QSemaphore(0);
 
    m_iCurrentReadIndex = -1;
    m_iCurrentWriteIndex = -1;
}
 
//=============================================================================================================
 
template<typename T>
inline void CircularBuffer<T>::pause(bool bPause)
{
    m_bPause = bPause;
}
 
//=============================================================================================================
 
template<typename T>
inline int CircularBuffer<T>::getFreeElementsRead()
{
    return m_pUsedElements->available();
}
 
//=============================================================================================================
 
template<typename T>
inline int CircularBuffer<T>::getFreeElementsWrite()
{
    return m_pFreeElements->available();
}
 
//=============================================================================================================
// TYPEDEF
//=============================================================================================================
 
typedef CircularBuffer<int> CircularBuffer_int;                                  
typedef CircularBuffer<short> CircularBuffer_short;                              
typedef CircularBuffer<char> CircularBuffer_char;                                
typedef CircularBuffer<double> CircularBuffer_double;                            
typedef CircularBuffer<QPair<int, int>> CircularBuffer_pair_int_int;             
typedef CircularBuffer<QPair<double, double>> CircularBuffer_pair_double_double; 
typedef CircularBuffer<Eigen::MatrixXd> CircularBuffer_Matrix_double;            
typedef CircularBuffer<Eigen::MatrixXf> CircularBuffer_Matrix_float;             
 
} // NAMESPACE
 
#endif // CIRCULARBUFFER_H