circularbuffer.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright 2015 Haye Hinrichsen, Christoph Wick
 *
 * This file is part of Entropy Piano Tuner.
 *
 * Entropy Piano Tuner is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * Entropy Piano Tuner is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * Entropy Piano Tuner. If not, see http://www.gnu.org/licenses/.
 *****************************************************************************/

//=============================================================================
//                             Circular buffer
//=============================================================================

#ifndef CIRCULAR_BUFFER
#define CIRCULAR_BUFFER

#include <vector>
#include <assert.h>
#include <cstring>
#include <algorithm>

#include "core/system/eptexception.h"


template <class data_type>
class CircularBuffer
{
public:
    CircularBuffer(std::size_t maximum_size = 0);   

    void clear();                                   
    void push_back(const data_type &data);          
    void resize(std::size_t maximum_size);          
    std::vector<data_type> getOrderedData() const;  
    std::vector<data_type> readData(size_t n);      
    std::size_t size() const {return mCurrentSize;} 
    std::size_t maximum_size() const
        {return mMaximumSize;}                      

private:
    std::size_t mCurrentWritePosition;              
    std::size_t mCurrentReadPosition;               
    std::size_t mMaximumSize;                       
    std::size_t mCurrentSize;                       
    std::vector<data_type> mData;                   
};



//=============================================================================
//    Circular buffer implementation (contained in header because of template)
//=============================================================================

//-----------------------------------------------------------------------------
//                              Constructor
//-----------------------------------------------------------------------------


template <class data_type>
CircularBuffer<data_type>::CircularBuffer(std::size_t maximum_size)
    : mCurrentWritePosition(0),
      mCurrentReadPosition(0),
      mMaximumSize(maximum_size),
      mCurrentSize(0),
      mData()
{
    mData.resize(mMaximumSize);
}


//-----------------------------------------------------------------------------
//                  Clear the buffer, keeping its maximal size
//-----------------------------------------------------------------------------


template <class data_type>
void CircularBuffer<data_type>::clear()
{
    mCurrentWritePosition = 0;
    mCurrentReadPosition = 0;
    mCurrentSize = 0;
}


//-----------------------------------------------------------------------------
//                        Append a new data element
//-----------------------------------------------------------------------------


template <class data_type>
void CircularBuffer<data_type>::push_back(const data_type &data)
{
    assert(mMaximumSize > 0);
    assert(mCurrentWritePosition < mMaximumSize);
    assert(mCurrentReadPosition < mMaximumSize);
    // write at the desired position
    mData[mCurrentWritePosition] = data;
    // update write pointer
    mCurrentWritePosition = (mCurrentWritePosition+1) % mMaximumSize;
    // update current size
    mCurrentSize = std::min(mCurrentSize + 1, mMaximumSize);
    // update read pointer (add mMaximumSize to keep it positive)
    mCurrentReadPosition = (mCurrentWritePosition + mMaximumSize - mCurrentSize) % mMaximumSize;
}


//-----------------------------------------------------------------------------
//                      Copy data in an ordered form
//-----------------------------------------------------------------------------


template <class data_type>
std::vector<data_type> CircularBuffer<data_type>::getOrderedData() const
{
    std::vector<data_type> data_out(mCurrentSize);
    // copy end
    std::size_t part1Size = std::min(mCurrentReadPosition + mCurrentSize, mMaximumSize) - mCurrentReadPosition;
    std::memcpy(data_out.data(), mData.data() + mCurrentReadPosition, part1Size * sizeof(data_type));

    // copy start
    std::size_t part2Size = mCurrentSize - part1Size;
    std::memcpy(data_out.data() + part1Size, mData.data(), part2Size * sizeof(data_type));

    return data_out;
}



//-----------------------------------------------------------------------------
//  Retrieve time-ordeded data with max size of n and remove if from the buffer
//-----------------------------------------------------------------------------


template <class data_type>
std::vector<data_type> CircularBuffer<data_type>::readData(size_t n)
{
    std::vector<data_type> data_out(std::move(getOrderedData()));
    if (data_out.size() > n) data_out.resize(n);

    EptAssert(mCurrentSize >= data_out.size(), "Do not read more data than existent.");

    // reset read position
    mCurrentReadPosition = (mCurrentReadPosition + data_out.size()) % mMaximumSize;
    mCurrentSize = mCurrentSize - data_out.size();

    return data_out;
}


//-----------------------------------------------------------------------------
//                            Resize the buffer
//-----------------------------------------------------------------------------


template <class data_type>
void CircularBuffer<data_type>::resize(std::size_t maximum_size)
{
    // we have to temporarily store the old data and rewrite at at position 0
    std::vector<data_type> old_data(std::move(getOrderedData()));
    mMaximumSize = maximum_size;
    // new current size is size of old data, or smaller)
    mCurrentSize = std::min(old_data.size(), maximum_size);
    // resize or internal data structure
    mData.resize(mMaximumSize);

    // dont copy data if new buffer is empty
    if (mMaximumSize == 0) return;

    // reset read and write pointers
    mCurrentReadPosition = 0;
    mCurrentWritePosition = mCurrentSize % mMaximumSize;
    // copy the old data
    std::memcpy(mData.data(),
                old_data.data() + (old_data.size() - mCurrentSize),
                mCurrentSize * sizeof(data_type));
}


#endif // CIRCULAR_BUFFER