GArray.h

Go to the documentation of this file.

#ifndef _GARRAY_H_
#define _GARRAY_H_

#include <stdlib.h>
#include <assert.h>
#include "LgiDefs.h"
#include "GMem.h"

#define GARRAY_MIN_SIZE         16

template <class Type>
class GArray
{
    Type *p;
    uint32 len;
    uint32 alloc;

protected:
    bool fixed;

public:
    GArray(int PreAlloc = 0)
    {
        p = 0;
        len = 0;
        fixed = false;

        alloc = PreAlloc;
        if (alloc)
        {
            int Bytes = sizeof(Type) * alloc;
            p = (Type*) malloc(Bytes);
            if (p)
            {
                memset(p, 0, Bytes);
            }
            else
            {
                alloc = 0;
            }
        }
    }

    GArray(const GArray<Type> &c)
    {
        p = 0;
        alloc = len = 0;
        fixed = false;
        *this = c;
    }

    ~GArray()
    {
        Length(0);
    }   
    
    uint32 Length() const
    {
        return len;
    }

    bool Length(uint32 i)
    {
        if (i > 0)
        {
            if (i > len && fixed)
                return false;

            uint nalloc = alloc;
            if (i < len)
            {
                // Shrinking
            }
            else
            {
                // Expanding
                int b;
                for (b = 4; (1 << b) < i; b++)
                    ;
                nalloc = 1 << b;
                LgiAssert(nalloc >= i);
            }
            
            if (nalloc != alloc)
            {
                Type *np = (Type*)malloc(sizeof(Type) * nalloc);
                if (!np)
                {
                    return false;
                }

                if (p)
                {
                    // copy across common elements
                    memcpy(np, p, min(len, i) * sizeof(Type));
                    free(p);
                }
                p = np;
                alloc = nalloc;
            }

            if (i > len)
            {
                // zero new elements
                memset(p + len, 0, sizeof(Type) * (nalloc - len));
            }

            len = i;
        }
        else
        {
            if (p)
            {
                int Length = len;
                for (uint i=0; i<Length; i++)
                {
                    p[i].~Type();
                }
                free(p);
                p = 0;
            }
            len = alloc = 0;
        }

        return true;
    }

    GArray<Type> &operator =(const GArray<Type> &a)
    {
        Length(a.Length());
        if (p && a.p)
        {
            for (int i=0; i<len; i++)
            {
                p[i] = a.p[i];
            }
        }
        return *this;
    }
    
    Type &operator [](uint32 i)
    {
        static Type t;
        if
        (
            i < 0
            ||
            (fixed && i >= len)
        )
        {
            ZeroObj(t);
            return t;
        }
        
        #if 1
        if (i > 64<<20)
        {
            #if defined(_DEBUG) && defined(_MSC_VER)
            LgiAssert(0);
            #endif
            
            ZeroObj(t);
            return t;
        }
        #endif

        if (i >= alloc)
        {
            // increase array length
            uint nalloc = max(alloc, GARRAY_MIN_SIZE);
            while (nalloc <= i)
            {
                nalloc <<= 1;
            }

            // alloc new array
            Type *np = (Type*) malloc(sizeof(Type) * nalloc);
            if (np)
            {
                // clear new cells
                memset(np + len, 0, (nalloc - len) * sizeof(Type));
                if (p)
                {
                    // copy across old cells
                    memcpy(np, p, len * sizeof(Type));
                    
                    // clear old array
                    free(p);
                }
                
                // new values
                p = np;
                alloc = nalloc;
            }
            else
            {
                static Type *t = 0;
                return *t;
            }
        }

        // adjust length of the the array
        if (i + 1 > len)
        {
            len = i + 1;
        }
        
        return p[i];
    }
    
    void DeleteObjects()
    {
        for (uint i=0; i<len; i++)
        {
            DeleteObj(p[i]);
        }
        Length(0);
    }
    
    void DeleteArrays()
    {
        for (int i=0; i<len; i++)
        {
            DeleteArray(p[i]);
        }
        Length(0);
    }
    
    int IndexOf(Type n)
    {
        for (uint i=0; i<len; i++)
        {
            if (p[i] == n) return i;
        }
        
        return -1;
    }

    bool HasItem(Type n)
    {
        return IndexOf(n) >= 0;
    }
    
    bool DeleteAt
    (
        uint Index,
        bool Ordered = false
    )
    {
        if (p && Index >= 0 && Index < len)
        {
            // Delete the object
            p[Index].~Type();

            // Move the memory up
            if (Index < len - 1)
            {
                if (Ordered)
                {
                    memmove(p + Index, p + Index + 1, (len - Index - 1) * sizeof(Type) );
                }
                else
                {
                    p[Index] = p[len-1];
                }
            }

            // Adjust length
            len--;

            // Kill the element at the end... otherwise New() returns non-zero data.
            memset(p + len, 0, sizeof(Type));
            return true;
        }
        
        return false;
    }

    bool Delete
    (
        Type n,
        bool Ordered = false
    )
    {
        int i = IndexOf(n);
        if (p && i >= 0)
        {
            return DeleteAt(i, Ordered);
        }
        
        return false;
    }

    void Add
    (
        const Type &n
    )
    {
        (*this)[len] = n;
    }

    void Add
    (
        Type *s,
        int count
        
    )
    {
        if (!s || count < 1)
            return;
            
        int i = len;
        Length(len + count);
        Type *d = p + i;
        while (count--)
        {
            *d++ = *s++;
        }
    }

    void Add
    (
        GArray<Type> &a
        
    )
    {
        int old = len;
        if (Length(len + a.Length()))
        {
            for (int i=0; i<a.Length(); i++, old++)
                p[old] = a[i];
        }
    }
    GArray<Type> &operator +(GArray<Type> &a)
    {
        Add(a);
        return *this;
    }

    bool AddAt
    (
        int Index,
        Type n
    )
    {
        // Make room
        if (Length(len + 1))
        {
            if (Index < len - 1)
            {
                // Shift elements after insert point up one
                memmove(p + Index + 1, p + Index, (len - Index - 1) * sizeof(Type) );
            }
            else if (Index >= len)
            {
                // Add at the end, not after the end...
                Index = len - 1;
            }

            // Insert item
            p[Index] = n;

            return true;
        }

        return false;
    }

    void Sort(int (*Compare)(Type*, Type*))
    {
        typedef int (*qsort_compare)(const void *, const void *);
        qsort(p, len, sizeof(Type), (qsort_compare)Compare);
    }

    Type &New()
    {
        return (*this)[len];
    }

    Type *Release()
    {
        Type *Ptr = p;
        p = 0;
        len = alloc = 0;
        return Ptr;
    }

    template <class T>
    class Iter
    {
        int i;
        int8 each_dir;
        GArray<T> *a;

    public:
        Iter(GArray<T> *arr, int pos)
        {
            i = pos;
            a = arr;
            each_dir = 0;
        }

        bool Each()
        {
            if (each_dir) i += each_dir;
            else each_dir = i == 0 ? 1 : -1;
            return In();
        }

        operator bool() { return In(); }
        bool In() { return i >= 0 && i < a->Length(); }
        bool End() { return i < 0 || i >= a->Length(); }
        T &operator *() { return (*a)[i]; }
        Iter<T> &operator ++() { i++; return *this; }
        Iter<T> &operator --() { i--; return *this; }
        Iter<T> &operator ++(int) { i++; return *this; }
        Iter<T> &operator --(int) { i--; return *this; }
    };

    typedef Iter<Type> I;
    I Start() { return I(this, 0); }
    I End() { return I(this, Length()-1); }
};

#endif

---