ExtendableStore< T > Class Template Reference

#include <array.h>

Class Description

template<typename T>
class mudbox::ExtendableStore< T >

This class is similar to Store, except that adding elements to the end of the array is guaranteed to be a constant-time operation.

Random access is also constant-time, although slightly slower than the regular Store class. Use this class only when you need to add several elements to the array quickly.

Definition at line 688 of file array.h.

Public Member Functions
	ExtendableStore ()
	~ExtendableStore ()
unsigned int	ItemCount () const
	Returns the number of items in the array. More...
void	SetItemCount (unsigned int iCount)
	Sets the logical size of the array. More...
void	Clear ()
	Clears the array and deallocates its memory. More...
void	Add (const T &t)
	Adds a new item to the array, increasing the array size by 1. More...
void	Extend (unsigned int iIndex)
	Extends the logical size of the array. More...
void	Fill (T cPattern)
	Fills the array with a specified element. More...
unsigned int	IndexOf (const T &pValue) const
	Returns the first index of the element equal to pValue. More...
T &	Last (void)
	Returns the last item in the array, or 0 if the array is empty. More...
T &	operator[] (unsigned int iIndex)
const T &	operator[] (unsigned int iIndex) const
void	Serialize (Stream &s)

Constructor & Destructor Documentation

ExtendableStore ( )

inline

Definition at line 702 of file array.h.

                      :
        m_iBlockItemCount(16384),
        m_iBlockPow(14),
        m_iBlockMask(0x3FFF),
        m_iLogicalItemCount(0),
        m_iAlignment(16)
    {
        
    };

~ExtendableStore ( )

inline

Definition at line 712 of file array.h.

    {
        Clear();
    };

Member Function Documentation

unsigned int ItemCount ( void  ) const

inline

Returns the number of items in the array.

Definition at line 718 of file array.h.

{ return m_iLogicalItemCount; }

void SetItemCount ( unsigned int  iCount )

inline

Sets the logical size of the array.

Returns true if successful.

If the new size is smaller than the current size, items at the end of the array will be discarded. If the new size is larger, then a new memory block will be allocated. In this case, the existing items will only be copied to the new block only if bKeepContent is set to true.

Parameters

[in]

iCount

The new size of the array

Definition at line 725 of file array.h.

          { if( iCount == 0 ) Clear(); else Extend( iCount-1 ); m_iLogicalItemCount = iCount; }

void Clear ( )

inline

Clears the array and deallocates its memory.

Definition at line 730 of file array.h.

    {
        m_iLogicalItemCount = 0;
        for( unsigned int i = 0; i < m_aBlocks.ItemCount(); ++i )
        {
            Block::AlignedFree( (void*)m_aBlocks[i] );
        }
        m_aBlocks.Clear();
    }

void Add ( const T &  t )

inline

Adds a new item to the array, increasing the array size by 1.

Parameters

[in]

t

The element to be added to the end of the array

Definition at line 741 of file array.h.

    {
        const unsigned int c = ItemCount();
        Extend(c);
        operator[](c) = t;
    }

void Extend ( unsigned int  iIndex )

inline

Extends the logical size of the array.

If the specified size is not larger than the current array, nothing will happen. Otherwise the logical size of the array will be extended to one more than the specified index. New memory will be allocated as necessary to hold the new items.

Parameters

[in]

iIndex

The array index to extend to. For example, if you specify 7, the new array will contain 8 elements (indexed 0 to 7).

Definition at line 755 of file array.h.

    {
        const unsigned int iBlock = iIndex >> m_iBlockPow;

        // extend the logical item count to include iIndex
        m_iLogicalItemCount = Max( iIndex + 1, m_iLogicalItemCount );

        // if this block has already be allocated we are done.
        if( iBlock < m_aBlocks.ItemCount() )
            return;

        // allocate enough blocks to include iIndex
        const unsigned int ic = m_aBlocks.ItemCount();
        m_aBlocks.Extend( iBlock );
        for( unsigned int i = ic; i < m_aBlocks.ItemCount(); ++i )
        {
            T* pNewBlock = (T*)Block::AlignedAlloc( sizeof(T) * m_iBlockItemCount, m_iAlignment );
            MB_ASSERT( ((size_t) pNewBlock) % m_iAlignment == 0 );
            m_aBlocks[i] = pNewBlock;
        }
    }

void Fill ( T  cPattern )

inline

Fills the array with a specified element.

Parameters

[in]

cPattern

The value to which every item in the array will be set

Definition at line 780 of file array.h.

    { 
        for ( unsigned int i = 0; i < m_aBlocks.ItemCount(); i++ )
            for( unsigned int j = 0; j < m_iBlockItemCount; ++j )
                m_aBlocks[i][j] = cPattern;
    }

unsigned int IndexOf ( const T &  pValue ) const

inline

Returns the first index of the element equal to pValue.

Note this method requires that operator == be defined for the type of data stored in the array. Returns the index of the first occurance of pValue or 0xffffffff if the array does not contain pValue.

Definition at line 793 of file array.h.

    {
        for(unsigned int i = 0; i < ItemCount(); ++i )
            if( (*this)[i] == pValue )
                return i;
        return 0xffffffff;
    };

T& Last ( void  )

inline

Returns the last item in the array, or 0 if the array is empty.

Definition at line 802 of file array.h.

{ if ( ItemCount() ) return operator []( ItemCount()-1 ); else throw new Error( "ExtenableStore::LastItem called for an empty store" ); };

T& operator[] ( unsigned int  iIndex )

inline

Definition at line 804 of file array.h.

    { 
        const unsigned int iBlock = iIndex >> m_iBlockPow;
        const unsigned int iBlockItem = iIndex & m_iBlockMask;
        return m_aBlocks[ iBlock ][iBlockItem];
    }

const T& operator[] ( unsigned int  iIndex ) const

inline

Definition at line 811 of file array.h.

    { 
        const unsigned int iBlock = iIndex >> m_iBlockPow;
        const unsigned int iBlockItem = iIndex & m_iBlockMask;
        return m_aBlocks[ iBlock ][iBlockItem];
    }

void Serialize

(

Stream &

s

)

Definition at line 331 of file stream.h.

{
    s == m_iBlockItemCount;
    s == m_iBlockPow;
    s == m_iBlockMask;
    s == m_iLogicalItemCount;
    s == m_iAlignment;
       
    if( s.IsStoring() )
    {
        s << m_aBlocks.ItemCount();
        for( unsigned int i = 0; i < m_aBlocks.ItemCount(); ++i )
           s.Write( (void*)m_aBlocks[i], sizeof(T) * m_iBlockItemCount );
    }
    else
    {
        unsigned int iC = 0;
        s >> iC;
        m_aBlocks.SetItemCount( iC );
        for( unsigned int i = 0; i < m_aBlocks.ItemCount(); ++i )
        {
            m_aBlocks[i] = (T*)Block::AlignedAlloc( sizeof(T) * m_iBlockItemCount, m_iAlignment );
            s.Read( (void*)m_aBlocks[i], sizeof(T) * m_iBlockItemCount );
        }
    }
}; 

---

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

• Mudbox/array.h
• Mudbox/stream.h