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