Class Array

core/src/core/array.h:32–161

// a 2D array as a T**, etc.
template <typename T, size_t N = 1>
class Array
{
public:
    size_t mSize;               // Size of the last dimension of this array. For an m x n array, this is n.
    unique_ptr<T[]> mElements;  // Contiguous buffer containing all elements of this array, in row-major order.
    Array<T*, N - 1> mPointers; // Array of rank N-1, containing pointers to "columns" of this array. For an
                                // m x n x k array, this is an m x n array of pointers, each pointing to k
                                // elements. Recursively, this will expand to a buffer of m * n elements,
                                // and an array of m pointers to n elements.
    size_t mSizes[N];

    // Default constructor creates an array of size 0.
    Array()
        : mSize(0)
        , mElements(nullptr)
        , mPointers()
    {}

    // Creates an array with the given dimensions.
    template <typename S, typename... Sizes>
    Array(S size, Sizes... sizes)
    {
        resize(size, sizes...);
    }

    ~Array()
    {}

    // Resizes this array to have the given dimensions.
    template <typename S, typename... Sizes>
    void resize(S size, Sizes... sizes)
    {
        auto sizeList = {sizes...};
        auto sizeArray = sizeList.begin();

        mSizes[0] = size;
        for (auto i = 1; i < N; ++i)
        {
            mSizes[i] = sizeArray[i - 1];
        }

        mSize = sizeArray[N - 2];

        auto numElements = size;
        for (auto i = 0; i < N - 1; ++i)
        {
            numElements *= sizeArray[i];
        }

        mElements = ipl::make_unique<T[]>(numElements);

        mPointers.resize(size, sizes...);

        auto stride = mSize;
        for (auto i = 0u; mSize > 0 && i < numElements / mSize; ++i)
        {
            mPointers.mElements[i] = &mElements[i * stride];
        }