CascadeArray.h

Go to the documentation of this file.

//
// CascadeArray.h - header file for class CascadeArray
//
// Copyright (c) 2002, Roku, LLC.  All rights reserved.
//

#ifndef _ROKU_INCLUDE_CASCADE_UTIL_CASCADEARRAY_H
#define _ROKU_INCLUDE_CASCADE_UTIL_CASCADEARRAY_H

#include <stdlib.h>
#include <string.h>
#include <cascade/CascadeObject.h>

class CascadeArray : public CascadeObject
{
public:
    CascadeArray( u32 inItemSize, u32 inDesiredItemCount = 0 );

    virtual ~CascadeArray();

    inline u32 Count() const { return mCount; };

    virtual bool Append( void *inItem, u32 &outIndex );

    virtual bool Insert( void *inItem, u32 &ioIndex );

    virtual bool Remove( void *inItemToRemove );

    bool RemoveAtIndex( u32 inIndex );

        inline void Empty( void ) { mCount = 0; }
    
    bool Swap( u32 inIndex1, u32 inIndex2 );

    bool AdjustAllocation( u32 inDesiredItemCount );
            
    void TrimAllocation( void );

    virtual bool FetchItem( u32 inIndex, void* outItem ) const;

    typedef int (ArraySortFunction)(const void *inItem1, const void *inItem2);

    virtual void Sort( ArraySortFunction *inFunction );

protected:
    u32 mItemSize;
    u32 mArraySize;
    u32 mCount;
    void *mData;
};


template <class T> class CascadeTemplateArray : public CascadeArray
{
public:
    CascadeTemplateArray( u32 inDesiredItemCount = 0 )
                        : CascadeArray( sizeof(T), inDesiredItemCount ){}
        
    virtual ~CascadeTemplateArray() {};
    
    // NOTE: These four functions appear here to suppress a warning about
    // the template functions hiding the base class implementation.  When
    // using a templated array, we do not want people calling the functions
    // that take void* anyway.
    virtual bool Append( void *inItem, u32 &outIndex ) { return false; }
    virtual bool Insert( void *inItem, u32 &ioIndex ) { return false; }
    virtual bool Remove( void *inItemToRemove ) { return false; }
    virtual bool FetchItem( u32 inIndex, void *outItem ) const { return false; }
    
    virtual bool Append( T &inItem, u32 &outIndex )
        { return CascadeArray::Append( &inItem, outIndex ); }

    virtual bool Insert( T &inItem, u32 &ioIndex )
        { return CascadeArray::Insert( &inItem, ioIndex ); }

    virtual bool Remove( T &inItemToRemove )
        { return CascadeArray::Remove( &inItemToRemove ); }

    virtual bool FetchItem( u32 inIndex, T &outItem ) const
        { return CascadeArray::FetchItem( inIndex, &outItem ); }

    virtual bool AppendArray( const CascadeTemplateArray<T> &inArray )
        {
            bool bRetVal = false;
            if( AdjustAllocation( mCount + inArray.Count() ) )
            {
                T* data = (T*)mData;
                ::memcpy( &data[mCount], 
                          inArray.mData, 
                          inArray.Count() * sizeof(T) );
                mCount += inArray.Count();
                bRetVal = true;
            }
            return bRetVal;
        }
    
    virtual bool InsertArray( CascadeTemplateArray<T> &inArray, u32 inIdx )
        {
            bool bRetVal = false;
            u32 newArraySize = mCount + inArray.Count();
            if( AdjustAllocation( newArraySize ) )
            {
                T* data = (T*)mData;
                u32 idx = inIdx;

                // Shift items from the index to the end out to their new home
                if( idx < mCount )
                {
                    // We don't seem to have memmove
                    u32 src = mCount - 1;
                    u32 dst = newArraySize - 1;
                    for(  ; src >= inIdx; src--, dst-- )
                        ::memcpy( &data[dst],
                                  &data[src],
                                  sizeof(T) );
                }
                else
                {
                    idx = mCount;
                }

                // Copy the input items in.
                ::memcpy( &data[idx], 
                          inArray.mData,
                          inArray.Count() * sizeof(T) );
                mCount += inArray.Count();
                bRetVal = true;
            }
            return bRetVal;
        }
};

#endif //_ROKU_INCLUDE_CASCADE_UTIL_CASCADEARRAY_H

// LOG
// 05-Feb-03    mjkobb          created
// 11-Aug-03    mjkobb      Added AppendArray
// 13-Apr-04    mjkobb      Made some functions const, added InsertArray
// 12-Apr-05    mjkobb      Made AppendArray take a const array

---