/*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

package androidx.media.filterfw;

import android.annotation.TargetApi;
import android.graphics.Bitmap;
import android.os.Build;
import android.renderscript.Allocation;
import android.renderscript.Element;
import android.renderscript.RenderScript;
import android.renderscript.Type;
import android.util.Log;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Arrays;
import java.util.Vector;

final class BackingStore {

    /** Access mode None: Frame data will not be accessed at all. */
    static final int ACCESS_NONE = 0x00;
    /** Access mode Bytes: Frame data will be accessed as a ByteBuffer. */
    static final int ACCESS_BYTES = 0x01;
    /** Access mode Texture: Frame data will be accessed as a TextureSource. */
    static final int ACCESS_TEXTURE = 0x02;
    /** Access mode RenderTarget: Frame data will be accessed as a RenderTarget. */
    static final int ACCESS_RENDERTARGET = 0x04;
    /** Access mode Object: Frame data will be accessed as a generic Object. */
    static final int ACCESS_OBJECT = 0x08;
    /** Access mode Bitmap: Frame data will be accessed as a Bitmap. */
    static final int ACCESS_BITMAP = 0x10;
    /** Access mode Allocation: Frame data will be accessed as a RenderScript Allocation. */
    static final int ACCESS_ALLOCATION = 0x20;

    private static final int BACKING_BYTEBUFFER = 1;
    private static final int BACKING_TEXTURE = 2;
    private static final int BACKING_OBJECT = 3;
    private static final int BACKING_BITMAP = 4;
    private static final int BACKING_ALLOCATION = 5;

    private final FrameType mType;
    private int[] mDimensions;
    private long mTimestamp = Frame.TIMESTAMP_NOT_SET;

    private final FrameManager mFrameManager;

    private Vector<Backing> mBackings = new Vector<Backing>();

    private boolean mWriteLocked = false;
    private int mReadLocks = 0;

    private int mRefCount = 1;

    /** The most up-to-date data backing */
    private Backing mCurrentBacking = null;

    /** The currently locked backing */
    private Backing mLockedBacking = null;

    // Public Methods //////////////////////////////////////////////////////////////////////////////
    public BackingStore(FrameType type, int[] dimensions, FrameManager frameManager) {
        mType = type;
        mDimensions = dimensions != null ? Arrays.copyOf(dimensions, dimensions.length) : null;
        mFrameManager = frameManager;
    }

    public FrameType getFrameType() {
        return mType;
    }

    public Object lockData(int mode, int accessFormat) {
        return lockBacking(mode, accessFormat).lock(accessFormat);
    }

    public Backing lockBacking(int mode, int access) {
        Backing backing = fetchBacking(mode, access);
        if (backing == null) {
            throw new RuntimeException("Could not fetch frame data!");
        }
        lock(backing, mode);
        return backing;
    }

    public boolean unlock() {
        if (mWriteLocked) {
            mWriteLocked = false;
        } else if (mReadLocks > 0) {
            --mReadLocks;
        } else {
            return false;
        }
        mLockedBacking.unlock();
        mLockedBacking = null;
        return true;
    }

    public BackingStore retain() {
        if (mRefCount >= 10) {
            Log.w("BackingStore", "High ref-count of " + mRefCount + " on " + this + "!");
        }
        if (mRefCount <= 0) {
            throw new RuntimeException("RETAINING RELEASED");
        }
        ++mRefCount;
        return this;
    }

    public BackingStore release() {
        if (mRefCount <= 0) {
            throw new RuntimeException("DOUBLE-RELEASE");
        }
        --mRefCount;
        if (mRefCount == 0) {
            releaseBackings();
            return null;
        }
        return this;
    }

    /**
     * Resizes the backing store. This invalidates all data in the store.
     */
    public void resize(int[] newDimensions) {
        Vector<Backing> resized = new Vector<Backing>();
        for (Backing backing : mBackings) {
            if (backing.resize(newDimensions)) {
                resized.add(backing);
            } else {
                releaseBacking(backing);
            }
        }
        mBackings = resized;
        mDimensions = newDimensions;
    }

    public int[] getDimensions() {
        return mDimensions;
    }

    public int getElementCount() {
        int result = 1;
        if (mDimensions != null) {
            for (int dim : mDimensions) {
                result *= dim;
            }
        }
        return result;
    }

    public void importStore(BackingStore store) {
        // TODO: Better backing selection?
        if (store.mBackings.size() > 0) {
            importBacking(store.mBackings.firstElement());
        }
        mTimestamp = store.mTimestamp;
    }

    /**
     * @return the timestamp
     */
    public long getTimestamp() {
        return mTimestamp;
    }

    /**
     * @param timestamp the timestamp to set
     */
    public void setTimestamp(long timestamp) {
        mTimestamp = timestamp;
    }

    // Internal Methods ////////////////////////////////////////////////////////////////////////////
    private Backing fetchBacking(int mode, int access) {
        Backing backing = getBacking(mode, access);
        if (backing == null) {
            backing = attachNewBacking(mode, access);
        }
        syncBacking(backing);
        return backing;
    }

    private void syncBacking(Backing backing) {
        if (backing != null && backing.isDirty() && mCurrentBacking != null) {
            backing.syncTo(mCurrentBacking);
        }
    }

    private Backing getBacking(int mode, int access) {
        // [Non-iterator looping]
        for (int i = 0; i < mBackings.size(); ++i) {
            final Backing backing = mBackings.get(i);

            int backingAccess =
                    (mode == Frame.MODE_WRITE) ? backing.writeAccess() : backing.readAccess();
            if ((backingAccess & access) == access) {
                return backing;
            }
        }
        return null;
    }

    private Backing attachNewBacking(int mode, int access) {
        Backing backing = createBacking(mode, access);
        if (mBackings.size() > 0) {
            backing.markDirty();
        }
        mBackings.add(backing);
        return backing;
    }

    private Backing createBacking(int mode, int access) {
        // TODO: If the read/write access flags indicate, make/fetch a GraphicBuffer backing.
        Backing backing = null;
        int elemSize = mType.getElementSize();
        if (shouldFetchCached(access)) {
            backing = mFrameManager.fetchBacking(mode, access, mDimensions, elemSize);
        }
        if (backing == null) {
            switch (access) {
                case ACCESS_BYTES:
                    backing = new ByteBufferBacking();
                    break;
                case ACCESS_TEXTURE:
                case ACCESS_RENDERTARGET:
                    backing = new TextureBacking();
                    break;
                case ACCESS_OBJECT:
                    backing = new ObjectBacking();
                    break;
                case ACCESS_BITMAP:
                    backing = new BitmapBacking();
                    break;
                case ACCESS_ALLOCATION:
                    if (!AllocationBacking.isSupported()) {
                        throw new RuntimeException(
                                "Attempted to create an AllocationBacking in context that does " +
                                "not support RenderScript!");
                    }
                    backing = new AllocationBacking(mFrameManager.getContext().getRenderScript());
                    break;
            }
            if (backing == null) {
                throw new RuntimeException(
                        "Could not create backing for access type " + access + "!");
            }
            if (backing.requiresGpu() && !mFrameManager.getRunner().isOpenGLSupported()) {
                throw new RuntimeException(
                        "Cannot create backing that requires GPU in a runner that does not " +
                        "support OpenGL!");
            }
            backing.setDimensions(mDimensions);
            backing.setElementSize(elemSize);
            backing.setElementId(mType.getElementId());
            backing.allocate(mType);
            mFrameManager.onBackingCreated(backing);
        }
        return backing;
    }

    private void importBacking(Backing backing) {
        // TODO: This actually needs synchronization between the two BackingStore threads for the
        // general case
        int access = backing.requiresGpu() ? ACCESS_BYTES : backing.readAccess();
        Backing newBacking = createBacking(Frame.MODE_READ, access);
        newBacking.syncTo(backing);
        mBackings.add(newBacking);
        mCurrentBacking = newBacking;
    }

    private void releaseBackings() {
        // [Non-iterator looping]
        for (int i = 0; i < mBackings.size(); ++i) {
            releaseBacking(mBackings.get(i));
        }
        mBackings.clear();
        mCurrentBacking = null;
    }

    private void releaseBacking(Backing backing) {
        mFrameManager.onBackingAvailable(backing);
    }

    private void lock(Backing backingToLock, int mode) {
        if (mode == Frame.MODE_WRITE) {
            // Make sure frame is not read-locked
            if (mReadLocks > 0) {
                throw new RuntimeException(
                        "Attempting to write-lock the read-locked frame " + this + "!");
            } else if (mWriteLocked) {
                throw new RuntimeException(
                        "Attempting to write-lock the write-locked frame " + this + "!");
            }
            // Mark all other backings dirty
            // [Non-iterator looping]
            for (int i = 0; i < mBackings.size(); ++i) {
                final Backing backing = mBackings.get(i);
                if (backing != backingToLock) {
                    backing.markDirty();
                }
            }
            mWriteLocked = true;
            mCurrentBacking = backingToLock;
        } else {
            if (mWriteLocked) {
                throw new RuntimeException("Attempting to read-lock locked frame " + this + "!");
            }
            ++mReadLocks;
        }
        mLockedBacking = backingToLock;
    }

    private static boolean shouldFetchCached(int access) {
        return access != ACCESS_OBJECT;
    }


    // Backings ////////////////////////////////////////////////////////////////////////////////////
    static abstract class Backing {
        protected int[] mDimensions = null;
        private int mElementSize;
        private int mElementID;
        protected boolean mIsDirty = false;

        int cachePriority = 0;

        public abstract void allocate(FrameType frameType);

        public abstract int readAccess();

        public abstract int writeAccess();

        public abstract void syncTo(Backing backing);

        public abstract Object lock(int accessType);

        public abstract int getType();

        public abstract boolean shouldCache();

        public abstract boolean requiresGpu();

        public abstract void destroy();

        public abstract int getSize();

        public void unlock() {
            // Default implementation does nothing.
        }

        public void setData(Object data) {
            throw new RuntimeException("Internal error: Setting data on frame backing " + this
                    + ", which does not support setting data directly!");
        }

        public void setDimensions(int[] dimensions) {
            mDimensions = dimensions;
        }

        public void setElementSize(int elemSize) {
            mElementSize = elemSize;
        }

        public void setElementId(int elemId) {
            mElementID = elemId;
        }

        public int[] getDimensions() {
            return mDimensions;
        }

        public int getElementSize() {
            return mElementSize;
        }

        public int getElementId() {
            return mElementID;
        }

        public boolean resize(int[] newDimensions) {
            return false;
        }

        public void markDirty() {
            mIsDirty = true;
        }

        public boolean isDirty() {
            return mIsDirty;
        }

        protected void assertImageCompatible(FrameType type) {
            if (type.getElementId() != FrameType.ELEMENT_RGBA8888) {
                throw new RuntimeException("Cannot allocate texture with non-RGBA data type!");
            } else if (mDimensions == null || mDimensions.length != 2) {
                throw new RuntimeException("Cannot allocate non 2-dimensional texture!");
            }
        }

    }

    static class ObjectBacking extends Backing {

        private Object mObject = null;

        @Override
        public void allocate(FrameType frameType) {
            mObject = null;
        }

        @Override
        public int readAccess() {
            return ACCESS_OBJECT;
        }

        @Override
        public int writeAccess() {
            return ACCESS_OBJECT;
        }

        @Override
        public void syncTo(Backing backing) {
            switch (backing.getType()) {
                case BACKING_OBJECT:
                    mObject = backing.lock(ACCESS_OBJECT);
                    backing.unlock();
                    break;
                case BACKING_BITMAP:
                    mObject = backing.lock(ACCESS_BITMAP);
                    backing.unlock();
                    break;
                default:
                    mObject = null;
            }
            mIsDirty = false;
        }

        @Override
        public Object lock(int accessType) {
            return mObject;
        }

        @Override
        public int getType() {
            return BACKING_OBJECT;
        }

        @Override
        public boolean shouldCache() {
            return false;
        }

        @Override
        public boolean requiresGpu() {
            return false;
        }

        @Override
        public void destroy() {
            mObject = null;
        }

        @Override
        public int getSize() {
            return 0;
        }

        @Override
        public void setData(Object data) {
            mObject = data;
        }

    }

    static class BitmapBacking extends Backing {

        private Bitmap mBitmap = null;

        @Override
        public void allocate(FrameType frameType) {
            assertImageCompatible(frameType);
        }

        @Override
        public int readAccess() {
            return ACCESS_BITMAP;
        }

        @Override
        public int writeAccess() {
            return ACCESS_BITMAP;
        }

        @Override
        public void syncTo(Backing backing) {
            int access = backing.readAccess();
            if ((access & ACCESS_BITMAP) != 0) {
                mBitmap = (Bitmap) backing.lock(ACCESS_BITMAP);
            } else if ((access & ACCESS_BYTES) != 0) {
                createBitmap();
                ByteBuffer buffer = (ByteBuffer) backing.lock(ACCESS_BYTES);
                mBitmap.copyPixelsFromBuffer(buffer);
                buffer.rewind();
            } else if ((access & ACCESS_TEXTURE) != 0) {
                createBitmap();
                RenderTarget renderTarget = (RenderTarget) backing.lock(ACCESS_RENDERTARGET);
                mBitmap.copyPixelsFromBuffer(
                        renderTarget.getPixelData(mDimensions[0], mDimensions[1]));
            } else if ((access & ACCESS_ALLOCATION) != 0 && AllocationBacking.isSupported()) {
                createBitmap();
                syncToAllocationBacking(backing);
            } else {
                throw new RuntimeException("Cannot sync bytebuffer backing!");
            }
            backing.unlock();
            mIsDirty = false;
        }

        @TargetApi(11)
        private void syncToAllocationBacking(Backing backing) {
            Allocation allocation = (Allocation) backing.lock(ACCESS_ALLOCATION);
            allocation.copyTo(mBitmap);
        }

        @Override
        public Object lock(int accessType) {
            return mBitmap;
        }

        @Override
        public int getType() {
            return BACKING_BITMAP;
        }

        @Override
        public boolean shouldCache() {
            return false;
        }

        @Override
        public boolean requiresGpu() {
            return false;
        }

        @Override
        public void destroy() {
            // As we share the bitmap with other backings (such as object backings), we must not
            // recycle it here.
            mBitmap = null;
        }

        @Override
        public int getSize() {
            return 4 * mDimensions[0] * mDimensions[1];
        }

        @Override
        public void setData(Object data) {
            // We can assume that data will always be a Bitmap instance.
            mBitmap = (Bitmap) data;
        }

        private void createBitmap() {
            mBitmap = Bitmap.createBitmap(mDimensions[0], mDimensions[1], Bitmap.Config.ARGB_8888);
        }
    }

    static class TextureBacking extends Backing {

        private RenderTarget mRenderTarget = null;
        private TextureSource mTexture = null;

        @Override
        public void allocate(FrameType frameType) {
            assertImageCompatible(frameType);
            mTexture = TextureSource.newTexture();
        }

        @Override
        public int readAccess() {
            return ACCESS_TEXTURE;
        }

        @Override
        public int writeAccess() {
            return ACCESS_RENDERTARGET;
        }

        @Override
        public void syncTo(Backing backing) {
            int access = backing.readAccess();
            if ((access & ACCESS_BYTES) != 0) {
                ByteBuffer pixels = (ByteBuffer) backing.lock(ACCESS_BYTES);
                mTexture.allocateWithPixels(pixels, mDimensions[0], mDimensions[1]);
            } else if ((access & ACCESS_BITMAP) != 0) {
                Bitmap bitmap = (Bitmap) backing.lock(ACCESS_BITMAP);
                mTexture.allocateWithBitmapPixels(bitmap);
            } else if ((access & ACCESS_TEXTURE) != 0) {
                TextureSource texture = (TextureSource) backing.lock(ACCESS_TEXTURE);
                int w = mDimensions[0];
                int h = mDimensions[1];
                ImageShader.renderTextureToTarget(texture, getRenderTarget(), w, h);
            } else if ((access & ACCESS_ALLOCATION) != 0 && AllocationBacking.isSupported()) {
                syncToAllocationBacking(backing);
            } else {
                throw new RuntimeException("Cannot sync bytebuffer backing!");
            }
            backing.unlock();
            mIsDirty = false;
        }

        @TargetApi(11)
        private void syncToAllocationBacking(Backing backing) {
            Allocation allocation = (Allocation) backing.lock(ACCESS_ALLOCATION);
            ByteBuffer pixels = ByteBuffer.allocateDirect(getSize());
            allocation.copyTo(pixels.array());
            mTexture.allocateWithPixels(pixels, mDimensions[0], mDimensions[1]);
        }

        @Override
        public Object lock(int accessType) {
            switch (accessType) {
                case ACCESS_TEXTURE:
                    return getTexture();

                case ACCESS_RENDERTARGET:
                    return getRenderTarget();

                default:
                    throw new RuntimeException("Illegal access to texture!");
            }
        }

        @Override
        public int getType() {
            return BACKING_TEXTURE;
        }

        @Override
        public boolean shouldCache() {
            return true;
        }

        @Override
        public boolean requiresGpu() {
            return true;
        }

        @Override
        public void destroy() {
            if (mRenderTarget != null) {
                mRenderTarget.release();
            }
            if (mTexture.isAllocated()) {
                mTexture.release();
            }
        }

        @Override
        public int getSize() {
            return 4 * mDimensions[0] * mDimensions[1];
        }

        private TextureSource getTexture() {
            if (!mTexture.isAllocated()) {
                mTexture.allocate(mDimensions[0], mDimensions[1]);
            }
            return mTexture;
        }

        private RenderTarget getRenderTarget() {
            if (mRenderTarget == null) {
                int w = mDimensions[0];
                int h = mDimensions[1];
                mRenderTarget = RenderTarget.currentTarget().forTexture(getTexture(), w, h);
            }
            return mRenderTarget;
        }

    }

    static class ByteBufferBacking extends Backing {

        ByteBuffer mBuffer = null;

        @Override
        public void allocate(FrameType frameType) {
            int size = frameType.getElementSize();
            for (int dim : mDimensions) {
                size *= dim;
            }
            mBuffer = ByteBuffer.allocateDirect(size);
        }

        @Override
        public int readAccess() {
            return ACCESS_BYTES;
        }

        @Override
        public int writeAccess() {
            return ACCESS_BYTES;
        }

        @Override
        public boolean requiresGpu() {
            return false;
        }

        @Override
        public void syncTo(Backing backing) {
            int access = backing.readAccess();
            if ((access & ACCESS_TEXTURE) != 0) {
                RenderTarget target = (RenderTarget) backing.lock(ACCESS_RENDERTARGET);
                GLToolbox.readTarget(target, mBuffer, mDimensions[0], mDimensions[1]);
            } else if ((access & ACCESS_BITMAP) != 0) {
                Bitmap bitmap = (Bitmap) backing.lock(ACCESS_BITMAP);
                bitmap.copyPixelsToBuffer(mBuffer);
                mBuffer.rewind();
            } else if ((access & ACCESS_BYTES) != 0) {
                ByteBuffer otherBuffer = (ByteBuffer) backing.lock(ACCESS_BYTES);
                mBuffer.put(otherBuffer);
                otherBuffer.rewind();
            } else if ((access & ACCESS_ALLOCATION) != 0 && AllocationBacking.isSupported()) {
                syncToAllocationBacking(backing);
            } else {
                throw new RuntimeException("Cannot sync bytebuffer backing!");
            }
            backing.unlock();
            mBuffer.rewind();
            mIsDirty = false;
        }

        @TargetApi(11)
        private void syncToAllocationBacking(Backing backing) {
            Allocation allocation = (Allocation) backing.lock(ACCESS_ALLOCATION);
            if (getElementId() == FrameType.ELEMENT_RGBA8888) {
                byte[] bytes = mBuffer.array();
                allocation.copyTo(bytes);
            } else if (getElementId() == FrameType.ELEMENT_FLOAT32) {
                float[] floats = new float[getSize() / 4];
                allocation.copyTo(floats);
                mBuffer.asFloatBuffer().put(floats);
            } else {
                throw new RuntimeException(
                        "Trying to sync to an allocation with an unsupported element id: "
                        + getElementId());
            }
        }

        @Override
        public Object lock(int accessType) {
            return mBuffer.rewind();
        }

        @Override
        public void unlock() {
            mBuffer.rewind();
        }

        @Override
        public int getType() {
            return BACKING_BYTEBUFFER;
        }

        @Override
        public boolean shouldCache() {
            return true;
        }

        @Override
        public void destroy() {
            mBuffer = null;
        }

        @Override
        public int getSize() {
            return mBuffer.remaining();
        }

    }

    @TargetApi(11)
    static class AllocationBacking extends Backing {

        private final RenderScript mRenderScript;
        private Allocation mAllocation = null;

        public AllocationBacking(RenderScript renderScript) {
            mRenderScript = renderScript;
        }

        @Override
        public void allocate(FrameType frameType) {
            assertCompatible(frameType);

            Element element = null;
            switch (frameType.getElementId()) {
                case FrameType.ELEMENT_RGBA8888:
                    element = Element.RGBA_8888(mRenderScript);
                    break;
                case FrameType.ELEMENT_FLOAT32:
                    element = Element.F32(mRenderScript);
                    break;
            }
            Type.Builder imageTypeBuilder = new Type.Builder(mRenderScript, element);
            imageTypeBuilder.setX(mDimensions.length >= 1 ? mDimensions[0] : 1);
            imageTypeBuilder.setY(mDimensions.length == 2 ? mDimensions[1] : 1);
            Type imageType = imageTypeBuilder.create();

            mAllocation = Allocation.createTyped(mRenderScript, imageType);
        }

        @Override
        public int readAccess() {
            return ACCESS_ALLOCATION;
        }

        @Override
        public int writeAccess() {
            return ACCESS_ALLOCATION;
        }

        @Override
        public boolean requiresGpu() {
            return false;
        }

        @Override
        public void syncTo(Backing backing) {
            int access = backing.readAccess();
            if ((access & ACCESS_TEXTURE) != 0) {
                RenderTarget target = (RenderTarget) backing.lock(ACCESS_RENDERTARGET);
                ByteBuffer pixels = ByteBuffer.allocateDirect(getSize());
                GLToolbox.readTarget(target, pixels, mDimensions[0], mDimensions[1]);
                mAllocation.copyFrom(pixels.array());
            } else if ((access & ACCESS_BITMAP) != 0) {
                Bitmap bitmap = (Bitmap) backing.lock(ACCESS_BITMAP);
                mAllocation.copyFrom(bitmap);
            } else if ((access & ACCESS_BYTES) != 0) {
                ByteBuffer buffer = (ByteBuffer) backing.lock(ACCESS_BYTES);
                if (buffer.order() != ByteOrder.nativeOrder()) {
                    throw new RuntimeException(
                            "Trying to sync to the ByteBufferBacking with non-native byte order!");
                }
                byte[] bytes;
                if (buffer.hasArray()) {
                    bytes = buffer.array();
                } else {
                    bytes = new byte[getSize()];
                    buffer.get(bytes);
                    buffer.rewind();
                }
                mAllocation.copyFromUnchecked(bytes);
            } else {
                throw new RuntimeException("Cannot sync allocation backing!");
            }
            backing.unlock();
            mIsDirty = false;
        }

        @Override
        public Object lock(int accessType) {
            return mAllocation;
        }

        @Override
        public void unlock() {
        }

        @Override
        public int getType() {
            return BACKING_ALLOCATION;
        }

        @Override
        public boolean shouldCache() {
            return true;
        }

        @Override
        public void destroy() {
            if (mAllocation != null) {
                mAllocation.destroy();
                mAllocation = null;
            }
        }

        @Override
        public int getSize() {
            int elementCount = 1;
            for (int dim : mDimensions) {
                elementCount *= dim;
            }
            return getElementSize() * elementCount;
        }

        public static boolean isSupported() {
            return Build.VERSION.SDK_INT >= 11;
        }

        private void assertCompatible(FrameType type) {
            // TODO: consider adding support for other data types.
            if (type.getElementId() != FrameType.ELEMENT_RGBA8888
                    && type.getElementId() != FrameType.ELEMENT_FLOAT32) {
                throw new RuntimeException(
                        "Cannot allocate allocation with a non-RGBA or non-float data type!");
            }
            if (mDimensions == null || mDimensions.length > 2) {
                throw new RuntimeException(
                        "Cannot create an allocation with more than 2 dimensions!");
            }
        }

    }

}