BatchArray.h

#pragma once
#include <algorithm>
#include <cstring>
#include <memory>
#include <vector>
#include <stdexcept>
 
namespace mmind {
namespace eye {

template <typename ElementData>
class BatchArray
{
public:
    BatchArray(size_t width) : _width(width) {}
    ~BatchArray() = default;

    size_t width() const { return _width; }

    size_t height() const { return _height; }

    void setHeight(size_t height)
    {
        if (height > _capacity) {
            reserve(height);
        }
        _height = height;
    }

    size_t capacity() const { return _capacity; }

    bool isEmpty() const { return _height == 0; }

    void reserve(size_t height)
    {
        if (_capacity >= height)
            return;
 
        std::shared_ptr<ElementData> pNewData(new ElementData[_width * height],
                                              [](ElementData* p) { delete[] p; });
        if (_pData) {
            memcpy(pNewData.get(), _pData.get(), _width * _height * sizeof(ElementData));
        }
        _capacity = height;
        _pData = std::move(pNewData);
    }

    bool append(const BatchArray& data)
    {
        if (_width != data.width())
            return false;
 
        if (_capacity - _height < data.height()) {
            reserve(data.height() + _height);
        }
        memcpy(_pData.get() + _height * _width, data.data(),
               data.height() * data.width() * sizeof(ElementData));
        _height += data.height();
        return true;
    }

    const ElementData* data() const { return _pData.get(); }

    ElementData* data() { return _pData.get(); }

    const ElementData& operator[](std::size_t n) const
    {
        if (n >= _height * _width || !_pData)
            throw std::out_of_range("invalid subscript");
        ElementData* data = _pData.get();
        return data[n];
    }

    ElementData& operator[](std::size_t n)
    {
        return const_cast<ElementData&>(static_cast<const BatchArray<ElementData>&>(*this)[n]);
    }

    const ElementData& at(uint32_t row, uint32_t col) const
    {
        if (row >= _height || col >= _width || !_pData)
            throw std::out_of_range("invalid subscript");
        ElementData* data = _pData.get();
        return data[row * _width + col];
    }

    ElementData& at(size_t row, size_t col)
    {
        return const_cast<ElementData&>(
            static_cast<const BatchArray<ElementData>&>(*this).at(row, col));
    }

    BatchArray<ElementData> clone() const
    {
        BatchArray<ElementData> copy(_width);
        copy.reserve(_height);
        memcpy(copy.data(), data(), _height * _width * sizeof(ElementData));
        copy.setHeight(_height);
        return copy;
    }

    void clear()
    {
        memset(_pData.get(), 0, _height * _width * sizeof(ElementData));
        _height = 0;
    }

    void flip(bool flipX, bool flipY)
    {
        auto* data = _pData.get();
        const size_t height = _height;
        const size_t width = _width;
 
        if (flipX) {
            const size_t rowsToFlip = height / 2;
            for (size_t i = 0; i < rowsToFlip; ++i) {
                const size_t mirrorRow = height - 1 - i;
                auto* rowStart = data + i * width;
                auto* mirrorRowStart = data + mirrorRow * width;
                std::swap_ranges(rowStart, rowStart + width, mirrorRowStart);
            }
        }
 
        if (flipY) {
            for (size_t i = 0; i < height; ++i) {
                auto* rowStart = data + i * width;
                std::reverse(rowStart, rowStart + width);
            }
        }
    }
 
private:
    size_t _width{0};
    size_t _height{0};
    size_t _capacity{0};
    std::shared_ptr<ElementData> _pData;
};
} // namespace eye
} // namespace mmind