OffsetArray.h

#ifndef COFFSETARRAY_H
#define COFFSETARRAY_H
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
BEGIN_MOOTOOLS_NAMESPACE
 
    #ifndef _DEBUG
    #define SIZET_SPLIT_LIMIT ((unsigned int)-1)
    #endif
 
    // This class is used to store value that can be greater than the unsigned int limit.
    // if the values are all below the unsigned int limit, they are stored as unsigned int.
    // if some values are greater than the unsigned int limit, they are stores as size_t starting from the first concerned values.
    //
    // The class is useful particularly to store pointer offsets as it offer a compact way to store the offsets.
    //
    // Important Note: this class only store POSITIVE offset.
    //      Under Win32 sizet == unsigned int meaning that the class has no meaning
    //      Anyway we use it instead of a simple CXUIntArray because of the serialization process
    //      Using the same serialization between x32 / x64 allows data exchange between both type of application
    class DLL_TOOLSFUNCTION COffsetArray
    {
        protected:
            // Note:
            // - size is user number of elements
            // - intSize is the number of int elements
            // - bufSize contains intBuffer size or sizetBuffer buffer size (if sizetBuf not empty)
            //   the total number of allocated elements (GetAllocatedSize() is egal to (bufSize or intSize+bufSize)
            unsigned int growBy; // Granularity
            unsigned int size, intSize, bufSize;
            unsigned int *intBuffer;
            SIZET *sizetBuffer;
 
    #ifdef _DEBUG
            unsigned int SIZET_SPLIT_LIMIT; // This is for debugging testing in W32 and to make testing easier with simple number
            unsigned int splitOperation;
    #endif
 
            unsigned int SplitArray(unsigned int index);
            unsigned int GetSizetSize() const; // Get the nbr of elements of SIZET buffer
            unsigned int GetAllocatedSize() const; // Get the upper bound valid limit
 
        public:
            COffsetArray();
            virtual ~COffsetArray();
 
            unsigned int GetSize() const;
            void SetSize(unsigned int size, int growBy = -1);
            void PreAllocate(int size, int newGrowBy = -1);
 
            void FreeExtra();
            void RemoveAll();
 
            SIZET operator[](unsigned int index) const;
            SIZET GetAt(unsigned int index) const;
            void SetAt(unsigned int index, SIZET value);
            void SetAtGrow(unsigned int index, SIZET value);
            void RemoveAt(unsigned int index);
    #ifndef MOOTOOLS_NO_ARCHIVE_SUPPORT
            void Serialize(CXArchive& ar);
    #endif
 
    #ifdef MOOTOOLS_PRIVATE_DEBUG
            void SetSplitLimit(unsigned int limit);
    #endif
 
    #ifdef _DEBUG
            void Dump() const;
    #endif
    };
 
    inline unsigned int COffsetArray::GetAllocatedSize() const
    {
        return (GetSizetSize() > 0) ? (intSize+bufSize) : bufSize;
    }
 
    inline unsigned int COffsetArray::GetSizetSize() const
    {
        XASSERT(intSize <= size);
        return size-intSize;
    }
 
    inline unsigned int COffsetArray::GetSize() const
    {
        return size;
    }
 
    inline SIZET COffsetArray::operator[](unsigned int index) const
    {
        XASSERT(index < size);
        if (index >= size)
            return 0;
 
        if (index < intSize)
            return intBuffer[index];
 
        return sizetBuffer[index-intSize];
    }
 
    inline SIZET COffsetArray::GetAt(unsigned int index) const
    {
        return (*this)[index];
    }
 
    inline void COffsetArray::SetAt(unsigned int index, SIZET value)
    {
        XASSERT(index < size);
        if (index >= size)
            return;
 
        if (value > SIZET_SPLIT_LIMIT)
            SplitArray(index);
 
        if (index < intSize)
        {
            intBuffer[index] = (unsigned int)value;
            return;
        }
 
        sizetBuffer[index-intSize] = value;
    }
 
    inline void COffsetArray::SetAtGrow(unsigned int index, SIZET value)
    {
        if (index >= size)
            SetSize(index+1, -1);
 
        SetAt(index, value);
    }
 
    inline void COffsetArray::RemoveAt(unsigned int index)
    {
        if (index >= size)
            return;
 
        if (index < intSize)
        {
            xmemmove_s(intBuffer + index, (size_t)intSize*sizeof(unsigned int),
                intBuffer+index+1, (intSize-(index+1))*sizeof(unsigned int));
        
            size--;
            intSize--;
        
            if (intSize == 0)
            {
                xDeallocateArray(intBuffer);
                intBuffer = NULL;
 
                XASSERT(size != 0 || !sizetBuffer);
                if (size == 0) // if size > 0, bufSize matches for the sizetBuf buffer size
                    bufSize = 0;
            }
        }
        else
        {
            XASSERT(sizetBuffer);
            xmemmove_s(sizetBuffer + (index-intSize), (size_t)GetSizetSize()*sizeof(SIZET),
                sizetBuffer+(index-intSize)+1, (GetSizetSize()-((index-intSize)+1))*sizeof(SIZET));
 
            size--;
 
            if (GetSizetSize() == 0)
            {
                xDeallocateArray(sizetBuffer);
                sizetBuffer = NULL;
                bufSize = intSize; // bufSize matched the sizetBuffer
            }
        }
    }
 
END_MOOTOOLS_NAMESPACE
 
#endif