SameSizeBuffers.h

Go to the documentation of this file.

 
#pragma once
 
#include <vector>
#include <boost/thread/mutex.hpp>
 
template <typename T, typename U>
class SameSizeBuffers
{
public:
    // Constructors
    SameSizeBuffers();
    SameSizeBuffers(int sizeOfBuffer);
    SameSizeBuffers(int sizeOfBuffer, int numBuffers);
 
    virtual ~SameSizeBuffers();
 
    // Getters
    int     GetNumBuffers       () const { return (int)_buffers.size(); }
    int     GetBufferSize       () const { return _bufferSize; }
    int     GetCurrentBuffer    () const { return _currentBuffer; }
    int     GetFirstBufferIndex () const { return _firstBufferIndex; }
    int     GetNumBuffersInRing () const { return max(_buffers.size() - _firstBufferIndex, 0); }
 
    int     GetNextBufferIndex  ();
    T*      operator[]          (int index);
 
    // Setters
    void    SetCurrentBuffer    (int value);
    int     ResetCurrentBuffer  ();
    void    SetFirstBufferIndex (int value);
 
    // Methods
    bool    CreateBuffers       (int bufferSize, int numBuffers);
    bool    SetBufferToValue    (int index, U value);
 
    bool    AddTogether         (int sourceIndex, int destIndex);
    bool    Subtract            (int sourceIndex, int destIndex);
    bool    CopyBufferIn        (U* buffer, int index);
    bool    AddBufferToAverage  (U* buffer, int index, int divisor);
    bool    CopyBufferOut       (U* buffer, int index);
    void    Clear();
 
private:
    std::vector<std::vector<T>> _buffers;
 
    boost::mutex    _mutex;
 
    int             _bufferSize;
    int             _currentBuffer;
    int             _firstBufferIndex;
    
    // Methods
    void    Init                ();
    void    DeleteAll           ();
    void    AddOrDeleteBuffers  (int numTotalBuffers);
 
    bool    UsingSameType() const { return (std::is_same<T, U>::value); }
 
};
 
 
// Implementation - included here since the class is templated.
 
template <typename T, typename U>
SameSizeBuffers<T, U>::SameSizeBuffers()
{
    Init();
}
 
template <typename T, typename U>
SameSizeBuffers<T, U>::SameSizeBuffers(int sizeOfBuffer)
{
    Init();
    _bufferSize = sizeOfBuffer;
}
 
template <typename T, typename U>
SameSizeBuffers<T, U>::SameSizeBuffers(int sizeOfBuffer, int numBuffers)
{
    Init();
    CreateBuffers(int bufferSize, int numBuffers);
}
 
template <typename T, typename U>
SameSizeBuffers<T, U>::~SameSizeBuffers()
{
    DeleteAll();
    _bufferSize = 0;
    _currentBuffer = -1;
    _firstBufferIndex = 0;
}
 
template <typename T, typename U>
void SameSizeBuffers<T, U>::Init()
{
    _bufferSize = 0;
    _currentBuffer = -1;
    _firstBufferIndex = 0;
}
 
template <typename T, typename U>
void SameSizeBuffers<T, U>::SetCurrentBuffer(int value)
{
    if (value < _buffers.size())
    {
        _currentBuffer = value;
    }
}
 
template <typename T, typename U>
void SameSizeBuffers<T, U>::DeleteAll()
{
    for (int i = (int)_buffers.size() - 1; i >= 0; i--)
    {
        _buffers[i].clear();
    }
    _buffers.clear();
}
 
template <typename T, typename U>
bool SameSizeBuffers<T, U>::CreateBuffers(int bufferSize, int numBuffers)
{
    bool result = false;
    try
    {
        boost::mutex::scoped_lock lock(_mutex);
        if (bufferSize == _bufferSize && numBuffers == _buffers.size())
            return true;
 
        if (bufferSize <= 0 || numBuffers <= 0)
        {
            DeleteAll();
        }
        else if (bufferSize == _bufferSize)
        {
            AddOrDeleteBuffers(numBuffers);
        }
        else
        {
            // Delete buffers and reallocate.
            _bufferSize = bufferSize;
            DeleteAll();
            for (int i = 0; i < numBuffers; i++)
            {
                _buffers.push_back(vector<T>(_bufferSize));
            }
        }
        result = true;
    }
    catch (exception&)
    {
    }
    return result;
}
 
template <typename T, typename U>
void SameSizeBuffers<T, U>::Clear()
{
    boost::mutex::scoped_lock lock(_mutex);
    DeleteAll();
}
 
template <typename T, typename U>
int SameSizeBuffers<T, U>::ResetCurrentBuffer()             
{ 
    boost::mutex::scoped_lock lock(_mutex);
    _currentBuffer = _firstBufferIndex; 
    return _firstBufferIndex;
}
 
template <typename T, typename U>
void SameSizeBuffers<T, U>::AddOrDeleteBuffers(int numTotalBuffers)
{
    int currentBufferCount = (int)_buffers.size();
    // We can use existing buffers here.  Add more as needed.
    if (numTotalBuffers > currentBufferCount)
    {
        for (int i = 0; i < numTotalBuffers - currentBufferCount; i++)
        {
            _buffers.push_back(vector<T>(_bufferSize));
        }
 
    }
    // Else, delete unneeded buffers.
    else
    {
        for (int i = currentBufferCount - 1; i >= numTotalBuffers; i--)
        {
            _buffers[i].clear();
            _buffers.erase(_buffers.begin() + i);
        }
    }
}
 
template <typename T, typename U>
T* SameSizeBuffers<T, U>::operator[](int index)
{
    boost::mutex::scoped_lock lock(_mutex);
    if (index < _buffers.size())
    {
        return _buffers[index].data();
    }
    return nullptr;
}
 
template <typename T, typename U>
int SameSizeBuffers<T, U>::GetNextBufferIndex()
{
    boost::mutex::scoped_lock lock(_mutex);
    ++_currentBuffer;
    // If we hit the end of our circular buffer...
    if (_currentBuffer >= _buffers.size())
    {
        // Set the current buffer to the beginning of the circular buffer.
        _currentBuffer = _firstBufferIndex;
    }
    return _currentBuffer;
}
 
template <typename T, typename U>
bool SameSizeBuffers<T, U>::CopyBufferIn(U* buffer, int index)
{
    bool result = false;
    boost::mutex::scoped_lock lock(_mutex);
 
    if (index < _buffers.size())
    {
        if (UsingSameType())
        {
            memcpy(_buffers[index].data(), buffer, _bufferSize * sizeof(T));
        }
        else
        {
            for (int i = 0; i < _bufferSize; i++)
            {
                _buffers[index][i] = static_cast<T>(*(buffer + i));
            }
        }
        result = true;
    }
    return result;
}
 
template <typename T, typename U>
bool SameSizeBuffers<T, U>::AddBufferToAverage(U* buffer, int index, int divisor)
{
    bool result = false;
    boost::mutex::scoped_lock lock(_mutex);
 
    if (index < _buffers.size())
    {
        if (UsingSameType())
        {
            for (int i = 0; i < _bufferSize; i++)
            {
                _buffers[index][i] = *(buffer + i) / static_cast<T>(divisor);
            }
        }
        else
        {
            for (int i = 0; i < _bufferSize; i++)
            {
                _buffers[index][i] = static_cast<T>(*(buffer + i) / divisor);
            }
        }
        result = true;
    }
    return result;
}
 
template <typename T, typename U>
bool SameSizeBuffers<T, U>::CopyBufferOut(U* buffer, int index)
{
    bool result = false;
    boost::mutex::scoped_lock lock(_mutex);
    if (index < _buffers.size())
    {
        if (UsingSameType())
        {
            memcpy(buffer, _buffers[index].data(), _bufferSize * sizeof(T));
        }
        else
        {
            for (int i = 0; i < _bufferSize; i++)
            {
                *(buffer + i) = static_cast<U>(_buffers[index][i]);
            }
        }
        result = true;
    }
 
    return result;
}
 
template <typename T, typename U>
bool SameSizeBuffers<T, U>::SetBufferToValue(int index, U value)
{
    bool result = false;
    boost::mutex::scoped_lock lock(_mutex);
 
    if (index < _buffers.size())
    {
        if (UsingSameType())
        {
            std::fill_n(_buffers[index].begin(), _bufferSize, value);
        }
        else
        {
            std::fill_n(_buffers[index].begin(), _bufferSize, static_cast<T>(value));
        }
        result = true;
    }
 
    return result;
}
 
template <typename T, typename U>
bool SameSizeBuffers<T, U>::AddTogether(int sourceIndex, int destIndex)
{
    bool result = false;
    boost::mutex::scoped_lock lock(_mutex);
 
    if (sourceIndex < (int)_buffers.size() && destIndex < (int)_buffers.size())
    {
        for (int i = 0; i < _bufferSize; i++)
        {
            _buffers[destIndex][i] += _buffers[sourceIndex][i];
        }
        result = true;
    }
    return result;
}
 
template <typename T, typename U>
bool SameSizeBuffers<T, U>::Subtract(int sourceIndex, int destIndex)
{
    bool result = false;
    boost::mutex::scoped_lock lock(_mutex);
 
    if (sourceIndex < _buffers.size() && destIndex < _buffers.size())
    {
        for (int i = 0; i < _bufferSize; i++)
        {
            _buffers[destIndex][i] -= _buffers[sourceIndex][i];
        }
        result = true;
    }
    return result;
}
 
template <typename T, typename U>
void SameSizeBuffers<T, U>::SetFirstBufferIndex(int value)
{ 
    boost::mutex::scoped_lock lock(_mutex);
    _firstBufferIndex = value; 
    if (_firstBufferIndex > _currentBuffer + 1)
    {
        _currentBuffer = _firstBufferIndex - 1;
    }
}