fifo_buffer_base.h

#pragma once

#include "direct_array_buffer.h"

BEGIN_NAMESPACE_MEMORY

template <typename T>
class FifoBufferBase : public IDirectArraySourceBuffer<T>, public IDirectArrayTargetBuffer<T>
{
public:
    FifoBufferBase(size_t aCapacity = 0);
    virtual ~FifoBufferBase() = default;

    size_t getReadPos() override;

    size_t getWritePos() override;

    size_t getSize() override;

    size_t getRemainingSize() override;

    virtual void setCapacity(size_t aCapacity);

    size_t getCapacity() const override;

    virtual bool isFull();

    virtual void reset();

    std::recursive_mutex& getLock() override;

    void incrementReadPosition(size_t pos) override;

    void incrementWritePosition(size_t pos) override;

protected:
    mutable std::recursive_mutex lock;
    size_t size{0};
    size_t capacity{0};

private:
    size_t readPos{0};
    size_t writePos{0};
};

template <typename T>
FifoBufferBase<T>::FifoBufferBase(size_t aCapacity)
{
    FifoBufferBase<T>::setCapacity(aCapacity);
}

template <typename T>
size_t FifoBufferBase<T>::getReadPos()
{
    std::lock_guard<std::recursive_mutex> guard(lock);
    return readPos;
}

template <typename T>
size_t FifoBufferBase<T>::getWritePos()
{
    std::lock_guard<std::recursive_mutex> guard(lock);
    return writePos;
}

template <typename T>
size_t FifoBufferBase<T>::getSize()
{
    std::lock_guard<std::recursive_mutex> guard(lock);
    return size;
}

template <typename T>
size_t FifoBufferBase<T>::getRemainingSize()
{
    std::lock_guard<std::recursive_mutex> guard(lock);
    return capacity - size;
}

template <typename T>
void FifoBufferBase<T>::setCapacity(size_t aCapacity)
{
    std::lock_guard<std::recursive_mutex> guard(lock);
    capacity = aCapacity;
    reset();
}

template <typename T>
size_t FifoBufferBase<T>::getCapacity() const
{
    std::lock_guard<std::recursive_mutex> guard(lock);
    return capacity;
}

template <typename T>
bool FifoBufferBase<T>::isFull()
{
    std::lock_guard<std::recursive_mutex> guard(lock);
    return (size == capacity) && (capacity > 0);
}

template <typename T>
void FifoBufferBase<T>::reset()
{
    std::lock_guard<std::recursive_mutex> guard(lock);
    readPos = writePos = size = 0;
}

template <typename T>
void FifoBufferBase<T>::incrementReadPosition(size_t pos)
{
    std::lock_guard<std::recursive_mutex> guard(lock);

    readPos += pos;
    if (readPos >= capacity)
        readPos = readPos - capacity;
    size -= pos;
}

template <typename T>
void FifoBufferBase<T>::incrementWritePosition(size_t pos)
{
    std::lock_guard<std::recursive_mutex> guard(lock);

    writePos += pos;
    if (writePos >= capacity)
        writePos = writePos - capacity;
    size += pos;
}

template <typename T>
std::recursive_mutex& FifoBufferBase<T>::getLock()
{
    return lock;
}

END_NAMESPACE_MEMORY