array_buffer.h

#pragma once

#include "direct_array_buffer.h"

BEGIN_NAMESPACE_MEMORY

template <typename T, typename I>
class BaseArrayDescImpl : public I
{
public:
    BaseArrayDescImpl(T* buffer, size_t capacity)
        : buffer(buffer)
        , capacity(capacity)
    {
    }

    std::recursive_mutex& getLock() override
    {
        return lock;
    }

    T* getData() const override
    {
        return buffer;
    }

    size_t getCapacity() const override
    {
        return capacity;
    }

private:
    std::recursive_mutex lock;
    T* buffer;
    size_t capacity;
};

template <typename T>
class ArrayBufferSourceDesc : public BaseArrayDescImpl<T, IDirectArraySourceBuffer<T>>
{
public:
    ArrayBufferSourceDesc(T* buffer, size_t capacity)
        : BaseArrayDescImpl<T, IDirectArraySourceBuffer<T>>(buffer, capacity)
        , readPos(0)
        , size(capacity)
    {
    }

    size_t getReadPos() override
    {
        std::lock_guard<std::recursive_mutex> guard(this->getLock());
        return readPos;
    }

    void incrementReadPosition(size_t pos) override
    {
        std::lock_guard<std::recursive_mutex> guard(this->getLock());
        readPos += pos;
        size -= pos;
    }

    size_t getSize() override
    {
        std::lock_guard<std::recursive_mutex> guard(this->getLock());
        return size;
    }

protected:
    size_t readPos;
    size_t size;
};

template <typename T>
class ArrayBufferSource : public ArrayBufferSourceDesc<T>
{
public:
    explicit ArrayBufferSource(size_t capacity)
        : ArrayBufferSourceDesc<T>(new T[capacity], capacity)
    {
    }

    ~ArrayBufferSource()
    {
        delete[] this->getData();
    }
};

template <typename T>
class ArrayBufferTargetDesc : public BaseArrayDescImpl<T, IDirectArrayTargetBuffer<T>>
{
public:
    ArrayBufferTargetDesc(T* buffer, size_t capacity)
        : BaseArrayDescImpl<T, IDirectArrayTargetBuffer<T>>(buffer, capacity)
        , remainingSize(capacity)
        , writePos(0)
    {
    }

    size_t getWritePos() override
    {
        std::lock_guard<std::recursive_mutex> guard(this->getLock());
        return writePos;
    }

    void incrementWritePosition(size_t pos) override
    {
        std::lock_guard<std::recursive_mutex> guard(this->getLock());
        writePos += pos;
        remainingSize -= pos;
    }

    size_t getRemainingSize() override
    {
        std::lock_guard<std::recursive_mutex> guard(this->getLock());
        return remainingSize;
    }

protected:
    size_t remainingSize;
    size_t writePos;
};

template <typename T>
class ArrayBufferTarget : public ArrayBufferTargetDesc<T>
{
public:
    explicit ArrayBufferTarget(size_t capacity)
        : ArrayBufferTargetDesc<T>(new T[capacity], capacity)
    {
    }

    ~ArrayBufferTarget()
    {
        delete[] this->getData();
    }
};

END_NAMESPACE_MEMORY