fbxarray.h

Go to the documentation of this file.

/****************************************************************************************
 
   Copyright (C) 2012 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>

#define FBXSDK_ARRAY_BLOCKSIZE 4

template <size_t TypeSize> class FbxArrayBase
{
public:
    inline int GetCount() const { return GetArrayCount(); }

    inline void Clear()
    {
        if (mBaseArray!=NULL)
        {
            FbxFree(mBaseArray);
            mArrayCount = 0;
            mBaseArray = NULL;
        }
    }


    inline void Empty()
    {
    #ifdef _DEBUG
        memset( mBaseArray+ GetHeaderOffset() ,0,GetArrayCount()*TypeSize);
    #endif
        SetArrayCount(0);
    }


    inline int Reserve(int pCapacity)
    {
        FBX_ASSERT( pCapacity > 0 );

        if( pCapacity )
        {
            const FbxUInt lTempNewBlockCount = ( (FbxUInt) (pCapacity + FBXSDK_ARRAY_BLOCKSIZE - 1 ) / FBXSDK_ARRAY_BLOCKSIZE );
            const FbxUInt lNewBlockCount = (lTempNewBlockCount > 1 ? lTempNewBlockCount : 1);

            int lArrayCount = GetArrayCount();
            int lBlockCount = GetBlockCount();

            const FbxUInt lOldArraySize = lArrayCount*TypeSize;
            const FbxUInt lNewArraySize = lNewBlockCount*FBXSDK_ARRAY_BLOCKSIZE*TypeSize;

            if (lNewBlockCount != (FbxUInt) lBlockCount)
            {
                char* lBaseArray = (char*)FbxRealloc(mBaseArray, (size_t) lNewArraySize+ GetHeaderOffset()  );
                if (!lBaseArray)
                    return GetBlockCount()*FBXSDK_ARRAY_BLOCKSIZE;
                mBaseArray = lBaseArray;
            }

            if( lNewBlockCount > (FbxUInt) lBlockCount ) {
                memset( ((char*)mBaseArray+ GetHeaderOffset() ) + lOldArraySize, 0, (size_t) (lNewArraySize-lOldArraySize) );
                SetArrayCount(lArrayCount);
            } else if (pCapacity < lArrayCount)
            {
                memset( ((char*)mBaseArray+ GetHeaderOffset() ) + pCapacity*TypeSize, 0, (size_t) (lNewArraySize-pCapacity*TypeSize) );
                SetArrayCount(pCapacity);
            }

            SetBlockCount(lNewBlockCount);
        }

        return GetBlockCount()*FBXSDK_ARRAY_BLOCKSIZE;
    }


    //  Differ from SetCount because array capacity can be lowered.

    inline void SetCount (int pCount)
    {
    #ifdef _DEBUG
        if (pCount<0)
        {
            FBX_ASSERT_NOW ("ArrayUL : Item count can't be negative");
            return ;
        }
    #endif
        int lArrayCount = GetArrayCount();
        if (pCount > lArrayCount)
        {
            AddMultiple( pCount-lArrayCount);
        } 
        else
        {
            SetArrayCount(pCount);
        }
    }

    inline void Resize(int pItemCount)
    {
        FBX_ASSERT( pItemCount >= 0 );

        const FbxUInt lTempNewBlockCount = ( (FbxUInt) (pItemCount + FBXSDK_ARRAY_BLOCKSIZE - 1 ) / FBXSDK_ARRAY_BLOCKSIZE );
        const FbxUInt lNewBlockCount = (lTempNewBlockCount > 1 ? lTempNewBlockCount : 1);

        int lArrayCount = GetArrayCount();
        int lBlockCount = GetBlockCount();

        const FbxUInt lOldArraySize = lArrayCount*TypeSize;
        const FbxUInt lNewArraySize = lNewBlockCount*FBXSDK_ARRAY_BLOCKSIZE*TypeSize;

        if (lNewBlockCount != (FbxUInt) lBlockCount)
        {
            char* lBaseArray = (char*)FbxRealloc(mBaseArray, (size_t) lNewArraySize+ GetHeaderOffset()  );
            if (!lBaseArray)
                return;
            mBaseArray = lBaseArray;
        }

        if( lNewBlockCount > (FbxUInt) lBlockCount )
        {
            memset( ((char*)mBaseArray+ GetHeaderOffset() ) + lOldArraySize, 0, (size_t) (lNewArraySize-lOldArraySize) );
        }
        else if (pItemCount < lArrayCount)
        {
            memset( ((char*)mBaseArray+ GetHeaderOffset() ) + pItemCount*TypeSize, 0, (size_t) (lNewArraySize-pItemCount*TypeSize) );
        }

        SetBlockCount(lNewBlockCount);
        SetArrayCount(pItemCount);
    }

    inline void AddMultiple(int pItemCount)
    {
        FBX_ASSERT( pItemCount > 0 );

        if( pItemCount )
        {
            int lArrayCount = GetArrayCount();
            int lBlockCount = GetBlockCount();
            const FbxUInt lTempNewBlockCount = ( (FbxUInt) (lArrayCount+pItemCount + FBXSDK_ARRAY_BLOCKSIZE - 1 ) / FBXSDK_ARRAY_BLOCKSIZE );
            const FbxUInt lNewBlockCount = (lTempNewBlockCount > 1 ? lTempNewBlockCount : 1);

            const FbxUInt lOldArraySize = lArrayCount*TypeSize;
            const FbxUInt lNewArraySize = lNewBlockCount*FBXSDK_ARRAY_BLOCKSIZE*TypeSize;

            FBX_ASSERT( lOldArraySize < lNewArraySize );

            if( lNewBlockCount > (FbxUInt) lBlockCount )
            {
                char* lBaseArray = (char*)FbxRealloc(mBaseArray, (size_t) lNewArraySize+ GetHeaderOffset()  );
                if (!lBaseArray)
                    return;
                mBaseArray = lBaseArray;
                lBlockCount = lNewBlockCount;
            }

            memset( ((char*)mBaseArray+ GetHeaderOffset() ) + lOldArraySize, 0, (size_t) (lNewArraySize-lOldArraySize) );
            SetArrayCount ( lArrayCount + pItemCount );
            SetBlockCount (lBlockCount);
        }
    }

//
//  WARNING!
//
//  Anything beyond these lines may not be documented accurately and is
//  subject to change without notice.
//
#ifndef DOXYGEN_SHOULD_SKIP_THIS
protected:
    struct Header {
        int mBlockCount;
    };

    inline FbxArrayBase() : mArrayCount(0), mBaseArray(NULL)
    {
    }

    inline ~FbxArrayBase(){
        Clear ();
    }

    inline int InsertAt(int pIndex, void *pItem)
    {
        int lArrayCount = GetArrayCount();
        int lBlockCount = GetBlockCount();

        FBX_ASSERT( pIndex >= 0 );

        if (pIndex>lArrayCount) {
            pIndex = GetArrayCount();
        }

        if (lArrayCount>= lBlockCount*FBXSDK_ARRAY_BLOCKSIZE)
        {
            // must Alloc.Realloc some new space

            // double the number of blocks.
            lBlockCount = ( 0 == lBlockCount ) ? 1 : lBlockCount * 2;
            char* lBaseArray = (char*)FbxRealloc(mBaseArray, (size_t) (lBlockCount*FBXSDK_ARRAY_BLOCKSIZE*TypeSize) + GetHeaderOffset() );
            if(!lBaseArray)
                return -1;
            mBaseArray = lBaseArray;
        }

        if (pIndex<lArrayCount)
        {
            // This is an insert
            memmove (&(mBaseArray[(pIndex+1)*TypeSize+ GetHeaderOffset() ]), &(mBaseArray[(pIndex)*TypeSize+ GetHeaderOffset()] ), TypeSize*(lArrayCount-pIndex));
        }

        memmove (&(mBaseArray[(pIndex)*TypeSize+ GetHeaderOffset() ]), pItem, TypeSize);

        SetArrayCount(lArrayCount+1);
        SetBlockCount(lBlockCount);

        return pIndex;
    }


    inline void* GetAt(int pIndex) { return &(mBaseArray[(pIndex)*TypeSize+ GetHeaderOffset() ]); }

    inline void RemoveAt(int pIndex)
    {

    #if defined(_DEBUG) && !defined(FBXSDK_ENV_MAC)
        if (!ValidateIndex( pIndex ))
        {
            return;
        }
    #endif
        int lArrayCount = GetArrayCount();
        if (pIndex+1<lArrayCount)
        {
            memmove (&(mBaseArray[(pIndex)*TypeSize+ GetHeaderOffset() ]), &(mBaseArray[(pIndex+1)*TypeSize+ GetHeaderOffset() ]), TypeSize*(lArrayCount-pIndex-1));
        }

        SetArrayCount( lArrayCount-1 );

    #ifdef _DEBUG
        memset( &(mBaseArray[(GetArrayCount())*TypeSize+ GetHeaderOffset() ]),0,TypeSize);
    #endif
    }


    inline bool ValidateIndex( int pIndex ) const
    {
        int lArrayCount = GetArrayCount();
        if (pIndex>=0 && pIndex<lArrayCount)
        {
            return true;
        } 
        else
        {
            FBX_ASSERT_NOW("Array : Index out of range");
            return false;
        }
    }

    inline Header* const GetHeader() const
    {
        return (Header* const)mBaseArray;
    }
    inline Header* GetHeader()
    {
        return (Header*)mBaseArray;
    }
    inline int GetHeaderOffset() const
    {
        return sizeof(Header);
    }
    inline int GetArrayCount() const
    {
        return mArrayCount;
    }
    inline void SetArrayCount(int pArrayCount)
    {
        mArrayCount = pArrayCount;
    }
    inline int GetBlockCount() const
    {
        return GetHeader() ? GetHeader()->mBlockCount : 0;
    }
    inline void SetBlockCount(int pArrayCount)
    {
        if (GetHeader()) GetHeader()->mBlockCount = pArrayCount;
    }

    int     mArrayCount;
    char*   mBaseArray;
#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS
};

template <class Type> class FbxArray : public FbxArrayBase<sizeof(Type)>
{
    typedef FbxArrayBase<sizeof(Type)> ParentClass;

#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 string.h
    FBX_ASSERT_STATIC(FBXSDK_IS_SIMPLE_TYPE(Type) || __is_enum(Type) || (__has_trivial_constructor(Type)&&__has_trivial_destructor(Type)) || !FBXSDK_IS_INCOMPATIBLE_WITH_ARRAY(Type));
#endif

public:
    FbxArray() : ParentClass() {}

    FbxArray(const FbxArray& pArrayTemplate) : ParentClass()
    {
        *this = pArrayTemplate;
    }

    ~FbxArray() {}

    inline int InsertAt(int pIndex, Type pItem)
    {
        return ParentClass::InsertAt( pIndex,&pItem );
    }

    inline Type RemoveAt(int pIndex)
    {
        Type tmpItem = GetAt(pIndex);
        ParentClass::RemoveAt( pIndex );
        return tmpItem;
    }

    inline Type RemoveLast()
    {
        return RemoveAt(ParentClass::GetArrayCount()-1);
    }

    inline bool RemoveIt(Type pItem)
    {
        int Index = Find (pItem);
        if (Index>=0)
        {
            RemoveAt (Index);
            return true;
        }
        return false;
    }

    inline Type &operator[](int pIndex) const
    {
    #if defined(_DEBUG) && !defined(FBXSDK_ENV_MAC)
        if (!ParentClass::ValidateIndex( pIndex ))
        {
            return (Type&)(ParentClass::mBaseArray[(0)*sizeof(Type)+ ParentClass::GetHeaderOffset()]);
        }
    #endif
        return (Type&)(ParentClass::mBaseArray[(pIndex)*sizeof(Type)+ ParentClass::GetHeaderOffset()]);
    }

    inline void SetAt(int pIndex, Type pItem)
    {
    #if defined(_DEBUG) && !defined(FBXSDK_ENV_MAC)
        if (!ParentClass::ValidateIndex( pIndex ))
        {
            return;
        }
    #endif
        GetArray()[pIndex] = pItem;
    }

    inline void SetLast(Type pItem)
    {
        SetAt (ParentClass::GetArrayCount()-1, pItem);
    }

    inline Type GetAt(int pIndex) const
    {
    #if defined(_DEBUG) && !defined(FBXSDK_ENV_MAC)
        if (!ParentClass::ValidateIndex( pIndex ))
        {
            return (Type&)(ParentClass::mBaseArray[(0)*sizeof(Type)+ ParentClass::GetHeaderOffset()]);
        }
    #endif
        return (Type&)(ParentClass::mBaseArray[(pIndex)*sizeof(Type)+ ParentClass::GetHeaderOffset()]);
    }

    inline Type GetFirst() const
    {
        FBX_ASSERT( ParentClass::GetArrayCount() >= 1 );
        return GetAt(0);
    }

    inline Type GetLast() const
    {
        FBX_ASSERT( ParentClass::GetArrayCount() >= 1 );
        return GetAt(ParentClass::GetArrayCount()-1);
    }

    inline int Find(Type pItem) const
    {
        return FindAfter( -1, pItem );
    }

    inline int FindAfter(int pAfterIndex, Type pItem) const
    {
    #ifdef _DEBUG
        if ( pAfterIndex > ParentClass::GetArrayCount() || pAfterIndex < -1 )
        {
            FBX_ASSERT_NOW ("ArrayUL : Search Begin Index out of range");
            return -1;
        }
    #endif
        int Count;
        for ( Count=pAfterIndex+1; Count<ParentClass::GetArrayCount(); Count++)
        {
            if (GetAt(Count)==pItem)
            {
                return Count;
            }
        }
        return -1;
    }

    inline int FindBefore(int pBeforeIndex, Type pItem) const
    {
    #ifdef _DEBUG
        if ( pBeforeIndex > ParentClass::GetArrayCount() || pBeforeIndex <= 0 )
        {
            FBX_ASSERT_NOW ("ArrayUL : Search Begin Index out of range");
            return -1;
        }
    #endif
        int Count;
        for ( Count=pBeforeIndex-1; Count>=0; Count--)
        {
            if (GetAt(Count)==pItem)
            {
                return Count;
            }
        }
        return -1;
    }

    inline int Add(Type pItem)
    {
        return InsertAt(ParentClass::GetArrayCount(), pItem);
    }

    inline int AddUnique(Type pItem)
    {
        int lReturnIndex = Find(pItem);
        if (lReturnIndex == -1)
        {
            lReturnIndex = Add(pItem);
        }
        return lReturnIndex;
    }

    inline void AddMultiple(FbxUInt pItemCount)
    {
        ParentClass::AddMultiple(pItemCount);
    }

    inline void AddArray(const FbxArray<Type> &pArray)
    {
        int lSourceIndex, lCount = pArray.GetCount();
        if( lCount == 0 ) return;
        int lDestinationIndex = ParentClass::GetCount();
        AddMultiple(lCount);
        for( lSourceIndex = 0; lSourceIndex < lCount; lSourceIndex++)
        {
            SetAt(lDestinationIndex++, pArray[lSourceIndex]);
        }
    }

    inline void AddArrayNoDuplicate(const FbxArray<Type> &pArray)
    {
        int i, lCount = pArray.GetCount();
        for( i = 0; i < lCount; i++)
        {
            Type lItem = pArray[i];
            if (Find(lItem) == -1)
            {
                Add(lItem);
            }
        }
    }

    inline void RemoveArray(const FbxArray<Type> &pArray)
    {
        int lRemoveIndex, lRemoveCount = pArray.GetCount();
        for( lRemoveIndex = 0; lRemoveIndex < lRemoveCount; lRemoveIndex++)
        {
            RemoveIt(pArray[lRemoveIndex]);
        }
    }

    inline Type* GetArray() const
    {
        if (ParentClass::mBaseArray == NULL)
            return NULL;

        return (Type*)(ParentClass::mBaseArray+ ParentClass::GetHeaderOffset()) ;
    }

    inline FbxArray<Type>& operator=(const FbxArray<Type>& pArrayTemplate)
    {
        if ( this != &pArrayTemplate )
        {
            ParentClass::Clear();

            int i, lCount = pArrayTemplate.GetCount();

            for (i = 0; i < lCount; i++)
            {
                Add(pArrayTemplate[i]);
            }
        }

        return (*this);
    }

    inline operator Type* ()
    {
        return GetArray();
    }
};

template <class Type> inline void FbxArrayDelete(FbxArray<Type>& Array)
{
    FbxUInt lItemCount = Array.GetCount();
    while( lItemCount )
    {
        lItemCount--;
        Type& Item = (Array.operator[](lItemCount));
        FbxDelete(Item);
        Item = NULL;
    }
    Array.Clear();
}

//
//  WARNING!
//
//  Anything beyond these lines may not be documented accurately and is
//  subject to change without notice.
//
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    class FbxArrayBase_Size
    {
    public:
        FbxArrayBase_Size(int pItemSize) : mItemSize(pItemSize) {}
        inline int GetTypeSize() const { return mItemSize; }

    private:
        int mItemSize;
    };

    template <class TypeSize> class FbxArrayBase_
    {
    protected:
        struct Header
        {
            int mArrayCount;
            int mBlockCount;
        };

        inline FbxArrayBase_(TypeSize pTypeSize) : mTypeSize(pTypeSize)
        {
            mBaseArray = NULL;
        }

        inline ~FbxArrayBase_()
        {
            Clear();
        }

        inline int GetTypeSize() const { return mTypeSize.GetTypeSize(); }

        inline int GetCount() const { return GetArrayCount(); }

        inline void Clear()
        {
            if (mBaseArray!=NULL)
            {
                FbxFree(mBaseArray);
                mBaseArray = NULL;
            }
        }

        inline void Empty()
        {
        #ifdef _DEBUG
            memset(mBaseArray+ GetHeaderOffset(), 0, GetArrayCount()*GetTypeSize());
        #endif
            SetArrayCount(0);
        }

        inline int Reserve(int pCapacity)
        {
            FBX_ASSERT( pCapacity > 0 );
            if( pCapacity )
            {
                const FbxUInt lTempNewBlockCount = ( (FbxUInt) (pCapacity + FBXSDK_ARRAY_BLOCKSIZE - 1 ) / FBXSDK_ARRAY_BLOCKSIZE );
                const FbxUInt lNewBlockCount = (lTempNewBlockCount > 1 ? lTempNewBlockCount : 1);

                int lArrayCount = GetArrayCount();
                int lBlockCount = GetBlockCount();

                const FbxUInt lOldArraySize = lArrayCount*GetTypeSize();
                const FbxUInt lNewArraySize = lNewBlockCount*FBXSDK_ARRAY_BLOCKSIZE*GetTypeSize();

                if (lNewBlockCount != (FbxUInt) lBlockCount)
                {
                    char* lBaseArray = (char*)FbxRealloc(mBaseArray, (size_t) lNewArraySize+ GetHeaderOffset()  );
                    if (!lBaseArray)
                        return GetBlockCount()*FBXSDK_ARRAY_BLOCKSIZE;
                    mBaseArray = lBaseArray;
                }

                if( lNewBlockCount > (FbxUInt) lBlockCount ) {
                    memset( ((char*)mBaseArray+ GetHeaderOffset() ) + lOldArraySize, 0, (size_t) (lNewArraySize-lOldArraySize) );
                    SetArrayCount(lArrayCount);
                } 
                else if (pCapacity < lArrayCount)
                {
                    memset( ((char*)mBaseArray+ GetHeaderOffset() ) + pCapacity*GetTypeSize(), 0, (size_t) (lNewArraySize-pCapacity*GetTypeSize()) );
                    SetArrayCount(pCapacity);
                }

                SetBlockCount(lNewBlockCount);
            }

            return GetBlockCount()*FBXSDK_ARRAY_BLOCKSIZE;
        }

        inline void SetCount(int pCount)
        {
        #ifdef _DEBUG
            if (pCount<0)
            {
                FBX_ASSERT_NOW ("ArrayUL : Item count can't be negative");
                return ;
            }
        #endif
            int lArrayCount = GetArrayCount();
            if (pCount > lArrayCount)
            {
                AddMultiple( pCount-lArrayCount);
            } 
            else
            {
                SetArrayCount(pCount);
            }
        }

        inline void Resize(int pItemCount)
        {
            FBX_ASSERT( pItemCount >= 0 );

            const FbxUInt lTempNewBlockCount = ( (FbxUInt) (pItemCount + FBXSDK_ARRAY_BLOCKSIZE - 1 ) / FBXSDK_ARRAY_BLOCKSIZE );
            const FbxUInt lNewBlockCount = (lTempNewBlockCount > 1 ? lTempNewBlockCount : 1);

            int lArrayCount = GetArrayCount();
            int lBlockCount = GetBlockCount();

            const FbxUInt lOldArraySize = lArrayCount*GetTypeSize();
            const FbxUInt lNewArraySize = lNewBlockCount*FBXSDK_ARRAY_BLOCKSIZE*GetTypeSize();

            if (lNewBlockCount != (FbxUInt) lBlockCount)
            {
                char* lBaseArray = (char*)FbxRealloc(mBaseArray, (size_t) lNewArraySize+ GetHeaderOffset()  );
                if (!lBaseArray)
                    return;
                mBaseArray = lBaseArray;
            }

            if( lNewBlockCount > (FbxUInt) lBlockCount )
            {
                memset( ((char*)mBaseArray+ GetHeaderOffset() ) + lOldArraySize, 0, (size_t) (lNewArraySize-lOldArraySize) );
            }
            else if (pItemCount < lArrayCount)
            {
                memset( ((char*)mBaseArray+ GetHeaderOffset() ) + pItemCount*GetTypeSize(), 0, (size_t) (lNewArraySize-pItemCount*GetTypeSize()) );
            }

            SetBlockCount(lNewBlockCount);
            SetArrayCount(pItemCount);
        }

        inline void AddMultiple(int pItemCount)
        {
            FBX_ASSERT( pItemCount > 0 );
            if( pItemCount )
            {
                int lArrayCount = GetArrayCount();
                int lBlockCount = GetBlockCount();
                const FbxUInt lTempNewBlockCount = ( (FbxUInt) (lArrayCount+pItemCount + FBXSDK_ARRAY_BLOCKSIZE - 1 ) / FBXSDK_ARRAY_BLOCKSIZE );
                const FbxUInt lNewBlockCount = (lTempNewBlockCount > 1 ? lTempNewBlockCount : 1);

                const FbxUInt lOldArraySize = lArrayCount*GetTypeSize();
                const FbxUInt lNewArraySize = lNewBlockCount*FBXSDK_ARRAY_BLOCKSIZE*GetTypeSize();

                FBX_ASSERT( lOldArraySize < lNewArraySize );

                if( lNewBlockCount > (FbxUInt) lBlockCount )
                {
                    char* lBaseArray = (char*)FbxRealloc(mBaseArray, (size_t) lNewArraySize+ GetHeaderOffset()  );
                    if (!lBaseArray)
                        return;
                    mBaseArray = lBaseArray;
                    lBlockCount = lNewBlockCount;
                }

                memset( ((char*)mBaseArray+ GetHeaderOffset() ) + lOldArraySize, 0, (size_t) (lNewArraySize-lOldArraySize) );
                SetArrayCount ( lArrayCount + pItemCount );
                SetBlockCount (lBlockCount);
            }
        }

        inline int InsertAt(int pIndex, void* pItem)
        {
            int lArrayCount = GetArrayCount();
            int lBlockCount = GetBlockCount();

            FBX_ASSERT( pIndex >= 0 );

            if (pIndex>lArrayCount) {
                pIndex = GetArrayCount();
            }

            if (lArrayCount>= lBlockCount*FBXSDK_ARRAY_BLOCKSIZE)
            {
                // must Alloc.Realloc some new space

                // double the number of blocks.
                lBlockCount = ( 0 == lBlockCount ) ? 1 : lBlockCount * 2;
                char* lBaseArray = (char*)FbxRealloc(mBaseArray, (size_t) (lBlockCount*FBXSDK_ARRAY_BLOCKSIZE*GetTypeSize()) + GetHeaderOffset() );
                if(!lBaseArray)
                    return -1;
                mBaseArray = lBaseArray;
            }

            if (pIndex<lArrayCount)
            {
                // This is an insert
                memmove (&(mBaseArray[(pIndex+1)*GetTypeSize()+ GetHeaderOffset() ]), &(mBaseArray[(pIndex)*GetTypeSize()+ GetHeaderOffset()] ), GetTypeSize()*(lArrayCount-pIndex));
            }

            memmove (&(mBaseArray[(pIndex)*GetTypeSize()+ GetHeaderOffset() ]), pItem, GetTypeSize());

            SetArrayCount(lArrayCount+1);
            SetBlockCount(lBlockCount);

            return pIndex;
        }


        inline void* GetAt(int pIndex) { return &(mBaseArray[(pIndex)*GetTypeSize()+ GetHeaderOffset()]); }

        inline void RemoveAt(int pIndex)
        {
        #if defined(_DEBUG) && !defined(FBXSDK_ENV_MAC)
            if (!ValidateIndex( pIndex ))
            {
                return;
            }
        #endif
            int lArrayCount = GetArrayCount();
            if (pIndex+1<lArrayCount)
            {
                memmove (&(mBaseArray[(pIndex)*GetTypeSize()+ GetHeaderOffset() ]), &(mBaseArray[(pIndex+1)*GetTypeSize()+ GetHeaderOffset() ]), GetTypeSize()*(lArrayCount-pIndex-1));
            }

            SetArrayCount( lArrayCount-1 );

        #ifdef _DEBUG
            memset( &(mBaseArray[(GetArrayCount())*GetTypeSize()+ GetHeaderOffset() ]),0,GetTypeSize());
        #endif
        }

        inline bool ValidateIndex( int pIndex ) const
        {
            int lArrayCount = GetArrayCount();
            if (pIndex>=0 && pIndex<lArrayCount)
            {
                return true;
            }
            else
            {
                FBX_ASSERT_NOW("Array : Index out of range");
                return false;
            }
        }

        inline const Header* GetHeader() const
        {
            return (const Header*)mBaseArray;
        }

        inline Header* GetHeader()
        {
            return (Header*)mBaseArray;
        }

        inline int GetHeaderOffset() const
        {
            return sizeof(Header);
        }

        inline int GetArrayCount() const
        {
            return GetHeader() ? GetHeader()->mArrayCount : 0;
        }

        inline void SetArrayCount(int pArrayCount)
        {
            if (GetHeader()) GetHeader()->mArrayCount = pArrayCount;
        }

        inline int GetBlockCount() const
        {
            return GetHeader() ? GetHeader()->mBlockCount : 0;
        }

        inline void SetBlockCount(int pArrayCount)
        {
            if (GetHeader()) GetHeader()->mBlockCount=pArrayCount;
        }

        char*       mBaseArray;
        TypeSize    mTypeSize;
    };

    // FbxArray<FbxArray<T> > is not supported.
    template <class Type> FBXSDK_INCOMPATIBLE_WITH_ARRAY_TEMPLATE(FbxArray<Type>);
#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS

#include <fbxsdk/fbxsdk_nsend.h>

#endif /* _FBXSDK_CORE_BASE_ARRAY_H_ */