fbxsdk/core/base/fbxarray.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_ARRAY_H_
#define _FBXSDK_CORE_BASE_ARRAY_H_

#include <fbxsdk/fbxsdk_def.h>

#include <fbxsdk/fbxsdk_nsbegin.h>

template <class T> class FbxArray
{
public:
        FbxArray() : mSize(0), mCapacity(0), mArray(NULL){}

        FbxArray(const FbxArray& pArray) : mSize(0), mCapacity(0), mArray(NULL){ *this = pArray; }

        FbxArray(int pCapacity) : mSize(0), mCapacity(0), mArray(NULL){ if( pCapacity > 0 ) Reserve(pCapacity); }

        ~FbxArray(){ Clear(); }

        inline int InsertAt(const int pIndex, const T pElement)
        {
                FBX_ASSERT_RETURN_VALUE(pIndex >= 0, -1);
                int lIndex = FbxMin(pIndex, mSize);
                if( mSize >= mCapacity )
                {
                        int lNewCapacity = FbxMax(mCapacity * 2, 1);    //Double capacity
                        T* lArray = Allocate(lNewCapacity);
                        FBX_ASSERT_RETURN_VALUE(lArray, -1);
                        mArray = lArray;
                        mCapacity = lNewCapacity;
                }

                if( lIndex < mSize )    //Move elements to leave a space open to insert the new element
                {
                        memmove(&mArray[lIndex + 1], &mArray[lIndex], (mSize - lIndex) * sizeof(T));
                }

                memcpy(&mArray[lIndex], &pElement, sizeof(T));
                mSize++;

                return lIndex;
        }

        inline int Add(const T pElement)
        {
                return InsertAt(mSize, pElement);
        }

        inline int AddUnique(const T pElement)
        {
                int lIndex = Find(pElement);
                return ( lIndex == -1 ) ? Add(pElement) : lIndex;
        }

        inline int Size() const { return mSize; }

        inline int Capacity() const { return mCapacity; }

        inline T& operator[](int pIndex) const
        {
        #ifdef _DEBUG
                FBX_ASSERT_MSG(pIndex >= 0, "Index is out of range!");
                if( pIndex >= mSize )
                {
                        if( pIndex < mCapacity )
                        {
                                FBX_ASSERT_NOW("Index is out of range, but not outside of capacity! Call SetAt() to use reserved memory.");
                        }
                        else FBX_ASSERT_NOW("Index is out of range!");
                }
        #endif
                return (T&)mArray[pIndex];
        }

        inline T GetAt(const int pIndex) const
        {
                return operator[](pIndex);
        }

        inline T GetFirst() const
        {
                return GetAt(0);
        }

        inline T GetLast() const
        {
                return GetAt(mSize-1);
        }

        inline int Find(const T pElement, const int pStartIndex=0) const
        {
                FBX_ASSERT_RETURN_VALUE(pStartIndex >= 0, -1);
                for( int i = pStartIndex; i < mSize; ++i )
                {
                        if( GetAt(i) == pElement ) return i;
                }
                return -1;
        }

        inline int FindReverse(const T pElement, const int pStartIndex=FBXSDK_INT_MAX) const
        {
                for( int i = FbxMin(pStartIndex, mSize-1); i >= 0; --i )
                {
                        if( GetAt(i) == pElement ) return i;
                }
                return -1;
        }

        inline bool Reserve(const int pCapacity)
        {
                FBX_ASSERT_RETURN_VALUE(pCapacity > 0, false);
                if( pCapacity > mCapacity )
                {
                        T* lArray = Allocate(pCapacity);
                        FBX_ASSERT_RETURN_VALUE(lArray, false);
                        mArray = lArray;
                        mCapacity = pCapacity;

                        //Initialize new memory to zero
                        memset(&mArray[mSize], 0, (mCapacity - mSize) * sizeof(T));
                }
                return true;
        }

        inline void SetAt(const int pIndex, const T pElement)
        {
                if( pIndex >= mSize )
                {
                        FBX_ASSERT_RETURN(pIndex < mCapacity);
                        mSize = pIndex + 1;
                }
                memcpy(&mArray[pIndex], &pElement, sizeof(T));
        }

        inline void SetFirst(const T pElement)
        {
                SetAt(0, pElement);
        }

        inline void SetLast(const T pElement)
        {
                SetAt(mSize-1, pElement);
        }

        inline T RemoveAt(const int pIndex)
        {
                T lElement = GetAt(pIndex);
                if( pIndex + 1 < mSize )
                {
                        memmove(&mArray[pIndex], &mArray[pIndex + 1], (mSize - pIndex - 1) * sizeof(T));
                }
                mSize--;
                return lElement;
        }

        inline T RemoveFirst()
        {
                return RemoveAt(0);
        }

        inline T RemoveLast()
        {
                return RemoveAt(mSize-1);
        }

        inline bool RemoveIt(const T pElement)
        {
                int Index = Find(pElement);
                if( Index >= 0 )
                {
                        RemoveAt(Index);
                        return true;
                }
                return false;
        }

        inline bool Resize(const int pSize)
        {
                if( pSize == 0 )
                {
                        Clear();
                        return true;
                }

                FBX_ASSERT_RETURN_VALUE(pSize > 0, false);
                if( pSize != mCapacity )
                {
                        T* lArray = Allocate(pSize);
                        FBX_ASSERT_RETURN_VALUE(lArray, false);
                        mArray = lArray;
                }

                if( pSize > mCapacity ) //Initialize new memory to zero
                {
                        memset(&mArray[mSize], 0, (pSize - mSize) * sizeof(T));
                }

                mSize = pSize;
                mCapacity = pSize;

                return true;
        }

        inline bool Grow(const int pSize)
        {
                return Resize(mSize + pSize);
        }

        inline void Clear()
        {
                if( mArray != NULL )
                {
                        mSize = 0;
                        mCapacity = 0;
                        FbxFree(mArray);
                        mArray = NULL;
                }
        }

        inline T* GetArray() const { return mArray ? (T*)mArray : NULL; }

        inline operator T* (){ return (T*)mArray; }

        inline void AddArray(const FbxArray<T>& pOther)
        {
                if( Grow(pOther.mSize) )
                {
                        memcpy(&mArray[mSize - pOther.mSize], pOther.mArray, pOther.mSize * sizeof(T));
                }
        }

        inline void AddArrayNoDuplicate(const FbxArray<T>& pOther)
        {
                for( int i = 0, c = pOther.mSize; i < c; ++i )
                {
                        AddUnique(pOther[i]);
                }
        }

        inline void RemoveArray(const FbxArray<T>& pOther)
        {
                for( int i = 0, c = pOther.mSize; i < c; ++i )
                {
                        RemoveIt(pOther[i]);
                }
        }

        inline FbxArray<T>& operator=(const FbxArray<T>& pOther)
        {
                if( this != &pOther )
                {
                        if( Resize(pOther.mSize) )
                        {
                                memcpy(mArray, pOther.mArray, pOther.mSize * sizeof(T));
                        }
                }
                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
        inline int GetCount() const { return mSize; }
        FBX_DEPRECATED inline void Empty(){ Clear(); }
        FBX_DEPRECATED inline int FindAfter(int pAfterIndex, T pItem) const { return Find(pItem, pAfterIndex+1); }
        FBX_DEPRECATED inline int FindBefore(int pBeforeIndex, T pItem) const { return FindReverse(pItem, pBeforeIndex-1); }
        FBX_DEPRECATED inline void AddMultiple(int pItemCount){ Grow(pItemCount); }

private:
        inline T* Allocate(const int pCapacity)
        {
                return (T*)FbxRealloc(mArray, pCapacity * sizeof(T));
        }

        int             mSize;
        int             mCapacity;
        T*      mArray;

#if defined(FBXSDK_COMPILER_MSC)
    //Previously class FbxArray is for pointers. Somehow, it's used to store other types. Here's a compile-time checking for known incompatible classes.
    //If it happens you find new incompatible ones, declare them with macro FBXSDK_INCOMPATIBLE_WITH_ARRAY. Also see file fbxstring.h.
    FBX_ASSERT_STATIC(FBXSDK_IS_SIMPLE_TYPE(T) || __is_enum(T) || (__has_trivial_constructor(T)&&__has_trivial_destructor(T)) || !FBXSDK_IS_INCOMPATIBLE_WITH_ARRAY(T));
#endif

#endif /* !DOXYGEN_SHOULD_SKIP_THIS *****************************************************************************************/
};

template <class T> inline void FbxArrayFree(FbxArray<T>& pArray)
{
        for( int i = 0, c = pArray.Size(); i < c; ++i )
        {
                FbxFree(pArray[i]);
        }
        pArray.Clear();
}

template <class T> inline void FbxArrayDelete(FbxArray<T>& pArray)
{
        for( int i = 0, c = pArray.Size(); i < c; ++i )
        {
                FbxDelete(pArray[i]);
        }
        pArray.Clear();
}

template <class T> inline void FbxArrayDestroy(FbxArray<T>& pArray)
{
        for( int i = 0, c = pArray.Size(); i < c; ++i )
        {
                (pArray[i])->Destroy();
        }
        pArray.Clear();
}

template <class T> FBXSDK_INCOMPATIBLE_WITH_ARRAY_TEMPLATE(FbxArray<T>);

#include <fbxsdk/fbxsdk_nsend.h>

#endif /* _FBXSDK_CORE_BASE_ARRAY_H_ */