FBArrayTemplate< Type > Class Template Reference
 
 
 
FBArrayTemplate< Type > Class Template Reference

This reference page is linked to from the following overview topics: Data types & properties, Utility Classes, MotionBuilder 2014.


#include <fbarray.h>


Class Description

template<class Type>
class FBArrayTemplate< Type >

Template class to contain an array of items.

Note:
This utility template array only support plain old data structure (POD).

Definition at line 77 of file fbarray.h.

Public Member Functions

  FBArrayTemplate (int pItemPerBlock=10)
  Constructor.
  FBArrayTemplate (const FBArrayTemplate< Type > &pArrayTemplate)
  Copy constructor.
  ~FBArrayTemplate ()
  Destructor.
int  InsertAt (int pIndex, Type pItem)
  Insert pItem at pIndex.
void  RemoveAt (int pIndex)
  Remove item at pIndex.
void  RemoveLast ()
  Remove the last item in the array.
bool  Remove (Type &pItem)
  Remove pItem from the array.
bool  RemoveIt (Type pItem)
  Remove pItem from the array.
void  Clear ()
  Empty the array of all items.
Type &  operator[] (int pIndex) const
  [] operator overload.
void  SetAt (int pIndex, Type pItem)
  Set item at pIndex to pItem.
void  SetLast (Type pItem)
  Set the last item of the array.
int  GetCount () const
  Get the number of items in the array.
void  SetCount (int pCount)
  Set the number of items in the array.
Type  GetAt (int pIndex)
  Get item at pIndex.
Type  GetLast ()
  Get last item of the array.
int  Find (Type pItem)
  Find the index of pItem in the array.
int  Add (Type pItem)
  Add an item to the end of the array.
Type *  GetArray ()
  Get a pointer to the array of items.
FBArrayTemplate< Type > &  operator= (const FBArrayTemplate< Type > &pArrayTemplate)
  Copy array of pointers without copying the associated objects.

Constructor & Destructor Documentation

template<class Type>
FBArrayTemplate< Type >::FBArrayTemplate ( int  pItemPerBlock = 10 ) [inline]

Constructor.

Parameters:
pItemPerBlock Number of items per array block (default is 10).

Definition at line 83 of file fbarray.h.

        {
                mArray          = NULL;
                mArrayCount     = 0;
                mBlockCount     = 0;
                mItemPerBlock   = pItemPerBlock;    
        }
template<class Type>
FBArrayTemplate< Type >::FBArrayTemplate ( const FBArrayTemplate< Type > &  pArrayTemplate ) [inline]

Copy constructor.

Definition at line 92 of file fbarray.h.

    { 
        mArray          = NULL;
        mArrayCount     = 0;
        mBlockCount     = 0;
        mItemPerBlock   = 10;    

        *this = pArrayTemplate; 
    }
template<class Type>
FBArrayTemplate< Type >::~FBArrayTemplate ( ) [inline]

Destructor.

Definition at line 103 of file fbarray.h.

        {
                Clear();
        }

Member Function Documentation

template<class Type>
int FBArrayTemplate< Type >::InsertAt ( int  pIndex,
Type  pItem 
) [inline]

Insert pItem at pIndex.

Parameters:
pIndex Index to insert at.
pItem Item to insert.
Returns:
Actual insertion index where pItem was inserted.

Definition at line 113 of file fbarray.h.

        {
                if (pIndex>mArrayCount) 
                {
                        pIndex = mArrayCount;
                }

                if (mArrayCount>= mBlockCount*mItemPerBlock) 
                {
                         // must allocate or reallocate block of items
                          mBlockCount++;
                          mArray = (Type *)FBRealloc( mArray,(size_t)(mBlockCount*mItemPerBlock*sizeof(Type)));
                }

                if (pIndex<mArrayCount) 
                {
                        // This is an insert
                        memmove (&(mArray[pIndex+1]),&(mArray[pIndex]),sizeof(Type)*(mArrayCount-pIndex));
                }

                mArray[pIndex] = pItem;
                mArrayCount++;

                return pIndex;
        }
template<class Type>
void FBArrayTemplate< Type >::RemoveAt ( int  pIndex ) [inline]

Remove item at pIndex.

Parameters:
pIndex Index to remove item from.

Definition at line 142 of file fbarray.h.

        {
                assert( pIndex<mArrayCount );
                if (pIndex+1<mArrayCount) {
                        memmove (&(mArray[pIndex]),&(mArray[pIndex+1]),sizeof(Type)*(mArrayCount-pIndex-1));
                }
                mArrayCount --;
                memset (&(mArray[mArrayCount]),0,sizeof(Type)); // Cleanup last element to make sure we don't access it later
        }
template<class Type>
void FBArrayTemplate< Type >::RemoveLast ( ) [inline]

Remove the last item in the array.

Definition at line 154 of file fbarray.h.

{ RemoveAt( mArrayCount-1 ); }  
template<class Type>
bool FBArrayTemplate< Type >::Remove ( Type &  pItem ) [inline]

Remove pItem from the array.

Parameters:
pItem Item to remove.
Returns:
Operation was successful (true or false).

Definition at line 160 of file fbarray.h.

        {
          int Index = Find( pItem );
            if (Index>=0) {
                        RemoveAt( Index );
                        return true;
                }
                return false;
        }
template<class Type>
bool FBArrayTemplate< Type >::RemoveIt ( Type  pItem ) [inline]

Remove pItem from the array.

Parameters:
pItem Item to remove.
Returns:
Outcome of removal (true or false).

Definition at line 174 of file fbarray.h.

        {
          int Index = Find( pItem );
            if (Index>=0) {
                        RemoveAt( Index );
                        return true;
                }
                return false;
        }
template<class Type>
void FBArrayTemplate< Type >::Clear ( ) [inline]

Empty the array of all items.

Definition at line 185 of file fbarray.h.

        {
                if (mArray!=NULL) {
                        FBFree(mArray);
                        mArray = NULL;
                }
                mArrayCount  = 0L;
                mBlockCount  = 0L;
        }
template<class Type>
Type& FBArrayTemplate< Type >::operator[] ( int  pIndex ) const [inline]

[] operator overload.

Parameters:
pIndex Index of item to access.
Returns:
Item corresponding to pIndex.

Definition at line 199 of file fbarray.h.

        {
                assert( pIndex<mArrayCount );
                return mArray[pIndex];
        }
template<class Type>
void FBArrayTemplate< Type >::SetAt ( int  pIndex,
Type  pItem 
) [inline]

Set item at pIndex to pItem.

Parameters:
pIndex Index of item to set.
pItem Item to copy into the array.

Definition at line 209 of file fbarray.h.

        {
                assert( pIndex<mArrayCount );
                mArray[pIndex] = pItem;
        }
template<class Type>
void FBArrayTemplate< Type >::SetLast ( Type  pItem ) [inline]

Set the last item of the array.

Parameters:
pItem Item to copy as the last item of the array
Warning:
Will write over last item in the array!

Definition at line 219 of file fbarray.h.

        { 
                SetAt(mArrayCount-1,pItem ); 
        }
template<class Type>
int FBArrayTemplate< Type >::GetCount ( ) const [inline]

Get the number of items in the array.

Returns:
Number of items in the array.

Definition at line 227 of file fbarray.h.

        { 
                return mArrayCount; 
        }
template<class Type>
void FBArrayTemplate< Type >::SetCount ( int  pCount ) [inline]

Set the number of items in the array.

Definition at line 234 of file fbarray.h.

        {
                if (pCount > mArrayCount)
                {
                        if( pCount )
                        {
                                const int lTempNewBlockCount = ( (int) (mArrayCount+pCount + mItemPerBlock - 1 ) / mItemPerBlock );
                                const int lNewBlockCount = (lTempNewBlockCount > 1 ? lTempNewBlockCount : 1);

                                const int lOldArraySize = mArrayCount*sizeof(Type);
                                const int lNewArraySize = lNewBlockCount*mItemPerBlock*sizeof(Type);

                                if( lNewBlockCount > (int) mBlockCount )
                                {                       
                                        mArray = (Type *)FBRealloc( mArray, (size_t) lNewArraySize );
                                        mBlockCount = lNewBlockCount;
                                }
                                
                                memset( ((char *)mArray) + lOldArraySize, 0, (size_t) (lNewArraySize-lOldArraySize) );
                                mArrayCount += pCount;
                        }
                } else 
                {
                        mArrayCount = pCount;
                }
        }
template<class Type>
Type FBArrayTemplate< Type >::GetAt ( int  pIndex ) [inline]

Get item at pIndex.

Parameters:
pIndex Index of desired item.
Returns:
Item specified by pIndex.

Definition at line 265 of file fbarray.h.

        {               
                assert( pIndex<mArrayCount );
                return mArray[pIndex]; 
        }
template<class Type>
Type FBArrayTemplate< Type >::GetLast ( ) [inline]

Get last item of the array.

Returns:
Last item of the array.

Definition at line 274 of file fbarray.h.

        { 
                return mArray[mArrayCount-1]; 
        }
template<class Type>
int FBArrayTemplate< Type >::Find ( Type  pItem ) [inline]

Find the index of pItem in the array.

Parameters:
pItem Item to look for in the array.
Returns:
Index number of element found. Returns -1 if pItem was not found.

Definition at line 283 of file fbarray.h.

        {
          int Count;
                for (Count=0; Count<mArrayCount; Count++) {
                        if (mArray[Count]==pItem) {
                                return Count;
                        }
                }
                return -1;
        }
template<class Type>
int FBArrayTemplate< Type >::Add ( Type  pItem ) [inline]

Add an item to the end of the array.

Parameters:
pItem Item to insert into the array.
Returns:
Index where pItem was inserted.

Definition at line 298 of file fbarray.h.

        { 
                return InsertAt( mArrayCount,pItem ); 
        }
template<class Type>
Type* FBArrayTemplate< Type >::GetArray ( ) [inline]

Get a pointer to the array of items.

Returns:
Pointer to the array of items.
Warning:
Gives direct access to the array pointer!

Definition at line 307 of file fbarray.h.

        { 
                return mArray; 
        }
template<class Type>
FBArrayTemplate<Type>& FBArrayTemplate< Type >::operator= ( const FBArrayTemplate< Type > &  pArrayTemplate ) [inline]

Copy array of pointers without copying the associated objects.

Parameters:
pArrayTemplate Array to copy from.
Returns:
Pointer to the this class.

Definition at line 316 of file fbarray.h.

    {
        if (this != &pArrayTemplate)
        {
            Clear();

            mItemPerBlock = pArrayTemplate.mItemPerBlock;

            SetCount(pArrayTemplate.GetCount());
            memcpy(mArray, pArrayTemplate.mArray, sizeof(Type) * pArrayTemplate.GetCount());
        }

                return (*this);
        }

The documentation for this class was generated from the following file: