DynamicArray.h

Go to the documentation of this file.

#ifndef DYNAMICARRAY_H
#define DYNAMICARRAY_H

// dynamically allocated array

#include <new>

#ifdef _DEBUG
    #define DAINLINE
#else
    #define DAINLINE    inline
#endif

namespace VK_NoStepInto_Namespace {

template <class _Type>
class DynamicArray {
protected:
    unsigned long dwAllocBy;
    unsigned long dwAlloc;  // number of items allocated
    unsigned long dwInited; // number of items initialized

    // this should be true: dwNum <= dwInited <= dwAlloc

    bool InitItems (unsigned long dwStartIndex, unsigned long dwNumStructs);

public:
    _Type *lpBuffer;
    unsigned long dwNum;    // number of fields used
    DAINLINE unsigned long GetAllocated();

    DynamicArray (void);
    DynamicArray (unsigned long _dwAllocBy);
    DynamicArray (DynamicArray<_Type> &src);
    ~DynamicArray (void);

    DAINLINE const unsigned int size() const { return dwNum; };
        // to achieve greater similarity with std::vector

    DAINLINE void push_back(const _Type& elem) { AddItem(elem); }

    bool FreeArray (void);

    bool Truncate (void);
        // Lowers size of allocated memory to exact number of allocated items.

    bool PrepareNext (unsigned long _dwNum);

    bool Delete (unsigned long dwStartIndex, unsigned long dwNumStructs);

    DAINLINE bool DeleteAll(void);
    inline bool clear(void) { DeleteAll(); };
        // to achieve greater similarity with std::vector

    DAINLINE bool DeleteUnnecessary (void);

    bool Insert (unsigned long dwStartIndex, unsigned long dwNumStructs);

    bool CopyFrom (DynamicArray<_Type> *src);
        // Deletes everything and copies items from given array.
        // If the parameter is NULL, it only destroys everything.

    bool Swap (unsigned long dwIndex1, unsigned long dwIndex2);

    DAINLINE bool AddItem (const _Type& newItem);
        // Add item at the end of the array

    DAINLINE _Type &Last (void);

    DAINLINE _Type &Act (void);
    DAINLINE unsigned long &ActDWORD (void);
    DAINLINE int &ActInt (void);

    DAINLINE _Type &Get(unsigned long index) { return (*this)[index]; }
    DAINLINE const _Type &Get(unsigned long index) const { return (*this)[index]; }

    DAINLINE bool StoreByte (unsigned char bData);
        // !!! WARNING !!! Can be only used in arrays, which have size of item = 1 byte !!!
        // It also calls PrepareNext.
    DAINLINE bool StoreDWORD (unsigned long dwData);
        // !!! WARNING !!! Can be only used in arrays, which have size of item = 1, 2 or 4 bytes !!!
        // It also calls PrepareNext.

    DAINLINE unsigned char ReadByte (void);
        // !!! WARNING !!! Can be only used in arrays, which have size of item = 1 byte !!!
    DAINLINE unsigned long ReadDWORD (void);
        // !!! WARNING !!! Can be only used in arrays, which have size of item = 1, 2 or 4 bytes !!!

    DAINLINE _Type &operator[](unsigned long dw);
    DAINLINE const _Type &operator[](unsigned long dw) const;

    DAINLINE _Type &at(unsigned long dw) { return lpBuffer[dw]; };
    DAINLINE const _Type &at(unsigned long dw) const { return lpBuffer[dw]; };
};

template <class _Type>
DynamicArray<_Type>::DynamicArray (void)
{
    dwAllocBy = 1;

    dwNum = 0;
    dwInited = 0;

    lpBuffer = NULL;
    dwAlloc = 0;
}


template <class _Type>
DynamicArray<_Type>::DynamicArray (DynamicArray<_Type> &src)
{
    dwAllocBy = src.dwAllocBy;

    dwNum = 0;
    dwInited = 0;

    lpBuffer = NULL;
    dwAlloc = 0;

    CopyFrom (&src);
}


template <class _Type>
DynamicArray<_Type>::DynamicArray (unsigned long _dwAllocBy)
{
    dwAllocBy = _dwAllocBy;

    dwNum = 0;
    dwInited = 0;

    lpBuffer = NULL;
    dwAlloc = 0;
}


template <class _Type>
DynamicArray<_Type>::~DynamicArray (void)
{
    FreeArray ();
}

template <class _Type>
unsigned long DynamicArray<_Type>::GetAllocated()
{
    return dwAlloc;
}

template <class _Type>
bool DynamicArray<_Type>::FreeArray (void)
{
    if (!DeleteAll ())
        return false;

    if (lpBuffer) {
        free (lpBuffer);
        lpBuffer = NULL;
    }
    dwAlloc = dwNum = dwInited = 0;

    return true;
}


template <class _Type>
bool DynamicArray<_Type>::Truncate (void)
{
    unsigned long dw = dwAlloc - dwNum;

    if (!dw)
        return true;

    if (!Delete (dwNum, dw))
        return false;

    void *tmpMem;

    tmpMem = (_Type*)malloc (dwNum * sizeof (_Type));
    if (!tmpMem && dwNum)
        return false;
    memcpy (tmpMem, lpBuffer, dwNum * sizeof (_Type));
    free (lpBuffer);
    lpBuffer = (_Type*)tmpMem;
    dwAlloc = dwNum;
    dwInited = dwNum;

    return true;
}


template <class _Type>
bool DynamicArray<_Type>::PrepareNext (unsigned long _dwNum)
{
    unsigned long dw;
    unsigned long dwNN = dwNum + _dwNum;

    if (dwNN <= dwInited)
        return true;

    if (dwNN > dwAlloc) {

        void *tmpMem;
        unsigned long dwLAlloc = dwAlloc;

#if 0
        dw = ((dwNN + dwAllocBy - 1) / dwAllocBy) * dwAllocBy;
#else
        dw = dwNN + dwAllocBy - 1;
        dw = dw - (dw % dwAllocBy);
#endif


        tmpMem = (_Type*)malloc (dw * sizeof (_Type));
        if (!tmpMem)
            return false;

        if (lpBuffer) {
            memcpy (tmpMem, lpBuffer, dwInited * sizeof (_Type));
            free (lpBuffer);
        }

        dwAlloc = dw;

        lpBuffer = (_Type*)tmpMem;

    }

    if (!InitItems (dwInited, dwNN - dwInited))
        return false;
    dwInited = dwNN;

    return true;
}


template <class _Type>
bool DynamicArray<_Type>::InitItems (unsigned long dwStartIndex, unsigned long dwNumStructs)
{
    unsigned long dw;

    for (dw = dwStartIndex; dw < dwStartIndex + dwNumStructs; dw++) {
        new ((void*)(lpBuffer + dw)) _Type;
    }

    return true;
}


template <class _Type>
bool DynamicArray<_Type>::Delete (unsigned long dwStartIndex, unsigned long dwNumStructs)
{
    if ((dwStartIndex >= dwAlloc) || (dwStartIndex >= dwInited) || (!dwNumStructs))
        return true;

    unsigned long dw;

    if (dwStartIndex + dwNumStructs > dwInited)
        dwNumStructs = dwInited - dwStartIndex;

    for (dw = dwStartIndex; dw < dwStartIndex + dwNumStructs; dw++)
        ((_Type*)(lpBuffer + dw))->~_Type ();


    memcpy (lpBuffer + dwStartIndex, lpBuffer + dwStartIndex + dwNumStructs, (dwInited - dwNumStructs - dwStartIndex) * sizeof (_Type));

    dwInited -= dwNumStructs;

    if (dwStartIndex < dwNum) {
        if (dwStartIndex + dwNumStructs < dwNum)
            dwNum -= dwNumStructs;
        else
            dwNum = dwStartIndex;
    }

    return true;
}


template <class _Type>
DAINLINE bool DynamicArray<_Type>::DeleteAll (void)
{
    return Delete (0, dwAlloc);
}


template <class _Type>
DAINLINE bool DynamicArray<_Type>::DeleteUnnecessary (void)
{
    if (dwInited <= dwNum)
        return true;

    return Delete (dwNum, dwInited - dwNum);
}


template <class _Type>
bool DynamicArray<_Type>::Insert (unsigned long dwStartIndex, unsigned long dwNumStructs)
{
    if (!dwNumStructs)
        return true;

    if (!PrepareNext (dwNumStructs))
        return false;

    if (dwStartIndex >= dwNum) {
        dwNum += dwNumStructs;
        return true;
    }

    _Type *tmpObjs = NULL;
    if (!(tmpObjs = (_Type*)malloc (dwNumStructs * sizeof (_Type))))
        return false;
    memcpy (tmpObjs, lpBuffer + dwNum, dwNumStructs * sizeof (_Type));

    unsigned long dw;
    for (dw = dwNum + dwNumStructs - 1; dw >= dwStartIndex + dwNumStructs; dw--)
        lpBuffer[dw] = lpBuffer[dw - dwNumStructs];
    dwNum += dwNumStructs;

    memcpy (lpBuffer + dwStartIndex, tmpObjs, dwNumStructs * sizeof (_Type));
    free (tmpObjs);

    return true;
}


template <class _Type>
bool DynamicArray<_Type>::CopyFrom (DynamicArray<_Type> *src)
{
    FreeArray ();
    if (!src)
        return true;

    lpBuffer = (_Type*)malloc (src->dwNum * sizeof (_Type));
    if (!lpBuffer)
        return false;

    dwNum = dwAlloc = dwInited = src->dwNum;

    unsigned long dw;
    for (dw = 0; dw < src->dwNum; dw++) {
        new ((void*)(lpBuffer + dw)) _Type (src->lpBuffer[dw]);
    }

    return true;
}


template <class _Type>
bool DynamicArray<_Type>::Swap (unsigned long dwIndex1, unsigned long dwIndex2)
{
    if (dwIndex1 == dwIndex2)
        return true;

    if ((dwIndex1 >= dwInited) || (dwIndex2 >= dwInited))
        return false;

    _Type tmp;

    memcpy (&tmp, lpBuffer + dwIndex1, sizeof (_Type));
    memcpy (lpBuffer + dwIndex1, lpBuffer + dwIndex2, sizeof (_Type));
    memcpy (lpBuffer + dwIndex2, &tmp, sizeof (_Type));

    return true;
}


template <class _Type>
bool DynamicArray<_Type>::AddItem (const _Type& newItem)
{
    if (!PrepareNext (1))
        return false;
    lpBuffer[dwNum++] = newItem;
    return true;
}


template <class _Type>
DAINLINE _Type &DynamicArray<_Type>::operator[](unsigned long dw)
{ 
#ifdef _DEBUG
#ifdef WIN32
    if (dw >= dwAlloc)
        OutputDebugStringA ("ERROR: DynArray: index error: dw >= dwAlloc\n");
    if (dw >= dwInited)
        OutputDebugStringA ("ERROR: DynArray: index error: dw >= dwInited\n");
#endif
#endif
    return lpBuffer[dw];
}


template <class _Type>
DAINLINE const _Type &DynamicArray<_Type>::operator[](unsigned long dw) const
{
#ifdef _DEBUG
#ifdef WIN32
    if (dw >= dwAlloc)
        OutputDebugStringA ("ERROR: DynArray: index error: dw >= dwAlloc\n");
    if (dw >= dwInited)
        OutputDebugStringA ("ERROR: DynArray: index error: dw >= dwInited\n");
#endif
#endif
    return lpBuffer[dw];
}


template <class _Type>
DAINLINE _Type &DynamicArray<_Type>::Last (void)
{
#ifdef _DEBUG
#ifdef WIN32
    unsigned long dw = dwNum - 1;
    if (dw >= dwAlloc)
        OutputDebugStringA ("ERROR: DynArray: index error: dw >= dwAlloc\n");
    if (dw >= dwInited)
        OutputDebugStringA ("ERROR: DynArray: index error: dw >= dwInited\n");
#endif
#endif

    return (lpBuffer[dwNum - 1]);
}


template <class _Type>
DAINLINE _Type &DynamicArray<_Type>::Act (void)
{
#ifdef _DEBUG
#ifdef WIN32
    unsigned long dw = dwNum;
    if (dw >= dwAlloc)
        OutputDebugStringA ("ERROR: DynArray: index error: dw >= dwAlloc\n");
    if (dw >= dwInited)
        OutputDebugStringA ("ERROR: DynArray: index error: dw >= dwInited\n");
#endif
#endif

    return (lpBuffer[dwNum]);
}

template <class _Type>
DAINLINE unsigned long &DynamicArray<_Type>::ActDWORD (void)
{
    return (*((unsigned long*)(lpBuffer + dwNum)));
}

template <class _Type>
DAINLINE int &DynamicArray<_Type>::ActInt (void)
{
    return (*((int*)(lpBuffer + dwNum)));
}

template <class _Type>
DAINLINE bool DynamicArray<_Type>::StoreByte (unsigned char bData)
{
    if (sizeof (_Type) != 1)
        return false;

    if (!PrepareNext (1))
        return false;

    *((unsigned char*)(lpBuffer + dwNum)) = bData;
    dwNum++;

    return true;
}

template <class _Type>
DAINLINE bool DynamicArray<_Type>::StoreDWORD (unsigned long dwData)
{
    if ((4 % sizeof (_Type)) != 0)
        return false;
    if (!PrepareNext (4 / sizeof (_Type)))
        return false;

    *((unsigned long*)(lpBuffer + dwNum)) = dwData;
    dwNum += 4 / sizeof (_Type);

    return true;
}

template <class _Type>
DAINLINE unsigned char DynamicArray<_Type>::ReadByte (void)
{
    return *((unsigned char*)(lpBuffer + (dwNum++)));
}

template <class _Type>
DAINLINE unsigned long DynamicArray<_Type>::ReadDWORD (void)
{
    unsigned long dw = *((unsigned long*)(lpBuffer + dwNum));
    dwNum += 4 / sizeof (_Type);

    return dw;
}


} // VK_NoStepInto_Namespace


using VK_NoStepInto_Namespace::DynamicArray;


#endif // DYNAMICARRAY_H