fbxsdk/core/base/fbxdynamicarray.h

Go to the documentation of this file.

/****************************************************************************************
 
   Copyright (C) 2013 Autodesk, Inc.
   All rights reserved.
 
   Use of this software is subject to the terms of the Autodesk license agreement
   provided at the time of installation or download, or which otherwise accompanies
   this software in either electronic or hard copy form.
 
****************************************************************************************/

#ifndef _FBXSDK_CORE_BASE_DYNAMICARRAY_H_
#define _FBXSDK_CORE_BASE_DYNAMICARRAY_H_

#include <fbxsdk/fbxsdk_def.h>

#include <fbxsdk/core/base/fbxcontainerallocators.h>

#include <fbxsdk/fbxsdk_nsbegin.h>

template <typename VALUE_TYPE, typename ALLOCATOR = FbxBaseAllocator> class FbxDynamicArray
{
public:
    typedef VALUE_TYPE ValueType;
    typedef ALLOCATOR AllocatorType;

    FbxDynamicArray()
        : mArray(NULL)
        , mArrayCapacity(0)
        , mValueCount(0)
        , mAllocator(sizeof(ValueType))
    {
    }

    FbxDynamicArray(const size_t pInitialSize)
        : mArray(NULL)
        , mArrayCapacity(0)
        , mValueCount(0)
        , mAllocator(sizeof(ValueType))
    {
        Reserve(pInitialSize);
    }

    FbxDynamicArray(const FbxDynamicArray& pArray)
        : mArray(NULL)
        , mArrayCapacity(0)
        , mValueCount(0)
        , mAllocator(sizeof(ValueType))
    {
        Reserve(pArray.mArrayCapacity);
        CopyArray(mArray, pArray.mArray, pArray.mValueCount);
        mValueCount = pArray.mValueCount;
    }

    ~FbxDynamicArray()
    {        
        for (size_t i = 0; i < mValueCount; i++)
        {
            mArray[i].~VALUE_TYPE();
        }

        mAllocator.FreeMemory(mArray);
    }

    size_t GetCapacity() const
    {
        return mArrayCapacity;
    }

    size_t GetSize() const
    {
        return mValueCount;
    }

    void Reserve(const size_t pCount)
    {
        if (pCount > mArrayCapacity)
        {
            // We don't use mAllocator.PreAllocate, because we want our array
            // to be continuous in memory.
            void* lBuffer = mAllocator.AllocateRecords(pCount);
            ValueType* lNewArray = reinterpret_cast<ValueType*>(lBuffer);

            MoveArray(lNewArray, mArray, mValueCount);

            mAllocator.FreeMemory(mArray);
            mArray = lNewArray;
            mArrayCapacity = pCount;
        }
    }

    void PushBack(const ValueType& pValue, const size_t pNCopies = 1)
    {
        if (mValueCount + pNCopies > mArrayCapacity)
        {
            // grow by 50%
            size_t lNewSize = mArrayCapacity + mArrayCapacity / 2;

            if (mValueCount + pNCopies > lNewSize)
            {
                lNewSize = mValueCount + pNCopies;
            }

            Reserve(lNewSize);
        }

        FBX_ASSERT(mValueCount + pNCopies <= mArrayCapacity);

        Fill(mArray + mValueCount, pValue, pNCopies);

        mValueCount += pNCopies;
    }

    void Insert(const size_t pIndex, const ValueType& pValue, const size_t pNCopies = 1)
    {
        FBX_ASSERT(pIndex >= 0);
        FBX_ASSERT(pIndex <= mValueCount);

        ValueType lValue = pValue; // in case pValue is in array

        if (pNCopies == 0)
        {
        }
        else if (pIndex >= mValueCount)
        {
            PushBack(pValue, pNCopies);
        }
        else if (mValueCount + pNCopies > mArrayCapacity)
        {
            // not enough room
            // grow by 50%
            size_t lNewSize = mArrayCapacity + mArrayCapacity / 2;

            if (mValueCount + pNCopies > lNewSize)
            {
                lNewSize = mValueCount + pNCopies;
            }

            void* lBuffer = mAllocator.AllocateRecords(lNewSize);
            ValueType* lNewArray = reinterpret_cast<ValueType*>(lBuffer);

            MoveArray(lNewArray, mArray, pIndex); // copy prefix
            Fill(lNewArray + pIndex, pValue, pNCopies); // copy values
            MoveArray(lNewArray + pIndex + pNCopies, mArray + pIndex, mValueCount - pIndex); // copy suffix

            mAllocator.FreeMemory(mArray);
            mArray = lNewArray;
            mValueCount += pNCopies;
            mArrayCapacity = lNewSize;
        }
        else
        {
            // copy suffix backwards
            MoveArrayBackwards(mArray + pIndex + pNCopies, mArray + pIndex, mValueCount - pIndex);
            Fill(mArray + pIndex, pValue, pNCopies); // copy values
            mValueCount += pNCopies;
        }
    }

    void PopBack(size_t pNElements = 1)
    {
        FBX_ASSERT(pNElements <= mValueCount);
         
        for (size_t i = mValueCount - pNElements; i < mValueCount; i++)
        {
            mArray[i].~VALUE_TYPE();
        }

        mValueCount -= pNElements;
    }

    void Remove(const size_t pIndex, size_t pNElements = 1)
    {
        FBX_ASSERT(pIndex >= 0);
        FBX_ASSERT(pIndex <= mValueCount);
        FBX_ASSERT(pIndex + pNElements <= mValueCount);

        if (pIndex + pNElements >= mValueCount)
        {
            PopBack(pNElements);
        }
        else
        {            
            for (size_t i = pIndex; i < pIndex + pNElements; i++)
            {
                mArray[i].~VALUE_TYPE();
            }

            MoveOverlappingArray(mArray + pIndex, mArray + pIndex + pNElements, mValueCount - pNElements);

            mValueCount -= pNElements;
        }
    }

    ValueType& operator[](const size_t pIndex)
    {
        return *(mArray + pIndex);
    }

    ValueType const& operator[](const size_t pIndex) const
    {
        return *(mArray + pIndex);
    }

    FbxDynamicArray& operator=(const FbxDynamicArray& pArray)
    {
        Reserve(pArray.mArrayCapacity);
        CopyArray(mArray, pArray.mArray, pArray.mValueCount);
        mValueCount = pArray.mValueCount;

        return *this;
    }

/*****************************************************************************************************************************
** WARNING! Anything beyond these lines is for internal use, may not be documented and is subject to change without notice! **
*****************************************************************************************************************************/
#ifndef DOXYGEN_SHOULD_SKIP_THIS
private:
    static void CopyArray(ValueType* pDest, const ValueType* pSrc, size_t pCount)
    {
        for( int i = 0; i < int(pCount); i++ )
        {
                        new(&(pDest[i])) ValueType(pSrc[i]);    //in-place new won't allocate memory, so it is safe
        }
    }

    static void MoveArray(ValueType* pDest, const ValueType* pSrc, size_t pCount)
    {
        for( int i = 0; i < int(pCount); i++ )
        {
                        new(&(pDest[i])) ValueType(pSrc[i]);    //in-place new won't allocate memory, so it is safe
        }

        for( int i = 0; i < int(pCount); i++ )
        {
            pSrc[i].~VALUE_TYPE();
        }
    }

    static void MoveOverlappingArray(ValueType* pDest, const ValueType* pSrc, size_t pCount)
    {
                for( int i = 0; i < int(pCount); i++ )
                {
                        new(&(pDest[i])) ValueType(pSrc[i]);    //in-place new won't allocate memory, so it is safe
                        pSrc[i].~VALUE_TYPE();
                }
    }

    static void MoveArrayBackwards(ValueType* pDest, const ValueType* pSrc, size_t pCount)
    {
                for( int i = 0; i < int(pCount); ++i )
                {
                        new(&(pDest[pCount-1-i])) ValueType(pSrc[pCount-1-i]);  //in-place new won't allocate memory, so it is safe
                        pSrc[pCount-1-i].~VALUE_TYPE();
                }
    }

    static void Fill(ValueType* pDest, const ValueType& pValue, size_t pCount)
    {
                for( int i = 0; i < int(pCount); i++ )
                {
                        new(&(pDest[i])) ValueType(pValue);     //in-place new won't allocate memory, so it is safe
                }
    }

    ValueType*          mArray;
    size_t                      mArrayCapacity;
    size_t                      mValueCount;
    AllocatorType       mAllocator;
#endif /* !DOXYGEN_SHOULD_SKIP_THIS *****************************************************************************************/
};

#include <fbxsdk/fbxsdk_nsend.h>

#endif /* _FBXSDK_CORE_BASE_DYNAMICARRAY_H_ */