nonblockingfifobuffer.h

Go to the documentation of this file.

#pragma once

#include "memory.h"
#include <atomic>
#include <vector>

BEGIN_NAMESPACE_MEMORY

template <typename T>
class NonblockingFifoBuffer
{
    static_assert(std::is_trivially_copyable_v<T>, "Only trivially copyable types are supported in direct array source buffer.");

public:

    using BufferIndex = std::size_t;


    NonblockingFifoBuffer()
    {
        setCapacity(0);
    }

    explicit NonblockingFifoBuffer(const std::size_t aCapacity)
    {
        setCapacity(aCapacity);
    }

    ~NonblockingFifoBuffer()
    {
    }

    NonblockingFifoBuffer(const NonblockingFifoBuffer&) = delete;
    NonblockingFifoBuffer(const NonblockingFifoBuffer&&) = delete;
    NonblockingFifoBuffer& operator=(const NonblockingFifoBuffer&) = delete;
    NonblockingFifoBuffer& operator=(const NonblockingFifoBuffer&&) = delete;

    void setCapacity(const std::size_t aCapacity)
    {
        writeIndex = 0;
        readIndex = 0;
        buffer = std::vector<T>(aCapacity);
    }

    std::size_t getCapacity() const
    {
        return buffer.size();
    }

    std::size_t getSize() const
    {
        const BufferIndex cachedWriteIndex = writeIndex;
        if (readIndex <= cachedWriteIndex)
            return cachedWriteIndex - readIndex;
        else
            return (buffer.size() - readIndex) + cachedWriteIndex;
    }

    BufferIndex getIndex() const
    {
        return writeIndex;
    }

    size_t writeSamples(T* source, std::size_t size)
    {
        if (size > buffer.size())
        {
            throw "Buffer size exceeded";
        }
        size_t totalSizeWritten = size;

        if (writeIndex + size > buffer.size())
        {
            std::size_t sizeUntilFullCapacity = buffer.size() - writeIndex;
            writeSamples(source, sizeUntilFullCapacity);
            size -= sizeUntilFullCapacity;
            source += sizeUntilFullCapacity;
        }

        std::memcpy(&buffer.data()[writeIndex], source, size * sizeof(T));

        {
            BufferIndex newWriteIndex = writeIndex + size;
            if (newWriteIndex >= buffer.size())
                newWriteIndex -= buffer.size();
            writeIndex = newWriteIndex;
        }
        return totalSizeWritten;
    }

    size_t readSamples(T* destination, size_t count)
    {
        count = std::min(count, getSize());
        std::size_t readCapacity = 0;
        if (readIndex + count > buffer.size())
        {
            readCapacity = buffer.size() - readIndex;
            std::memcpy(destination, &buffer.data()[readIndex], readCapacity * sizeof(T));
            readIndex = 0;
            destination += readCapacity;
            count -= readCapacity;
        }
        std::memcpy(destination, &buffer.data()[readIndex], count * sizeof(T));
        readIndex += count;
        return count + readCapacity;
    }

private:
    std::vector<T> buffer;
    BufferIndex readIndex{};
    std::atomic<BufferIndex> writeIndex{};
};

END_NAMESPACE_MEMORY