Pasted

#ifndef __DYNAMICAR_H__
#define __DYNAMICAR_H__
#include "stdafx.h"
#include "SdiObject.h"
#include "TypeInfo.h"
#include "MemAlloc.h"
 
namespace SDICW
{
    // Base Dynamic array
    class CDynamicAr : CSdiObject
    {
    public:
        // constructors
        CDynamicAr(void);
        virtual ~CDynamicAr(void);
 
        // methods
        sdVoid *GetData();
        const sdVoid *GetData() const;
 
        sdBool IsValidIndex(sdInt i) const;
        sdInt Count() const;
 
        sdVoid Insert(sdInt index, sdInt count, sdInt elementSize);
        sdVoid InsertZeroed(sdInt index, sdInt count, sdInt elementSize);
 
        sdInt Add(sdInt count, sdInt elementSize);
        sdInt AddZeroed(sdInt elementSize, sdInt count = 1);
 
        sdBool Shrink(sdInt elementSize);
 
        sdVoid Empty(sdInt elementSize, sdInt slack = 0);
 
        sdVoid Swap(sdInt elemA, sdInt elemB, sdInt elementSize);
 
        sdBool Remove(sdInt index, sdInt count, sdInt elementSize);
    protected:
        // reallocates the memory space on m_data
        sdVoid ReAllocate(sdInt elementSize);
        CDynamicAr(sdInt inNum, sdInt elementSize);
 
        // vars
        sdVoid *m_data; // memory space where we store the elements
        sdInt m_arrayNum; // number of elements in array
        sdInt m_arrayMax; // array capacity
    };
 
    typedef CDynamicAr ParentClass;
 
    // Dynamic array with template
    template<class _T> class TDynamicAr : public CDynamicAr
    {
    public:
        typedef _T ElementType;
 
        TDynamicAr() : ParentClass()
        {
        }
 
        TDynamicAr(sdInt num) : ParentClass(num, sizeof(ElementType)), m_iterator(NULL)
        {
        }
 
        TDynamicAr(const TDynamicAr &another)
            : ParentClass(another.m_arrayNum, sizeof(ElementType)), m_iterator(NULL)
        {
            // if its class type
            if(TTypeInfo<ElementType>::IsDestructorNeeded())
            {
                m_arrayNum = 0;
                for(int i = 0; i < another.Count(); i++)
                {
                    new(*this)ElementType(another[i]);
                }
            }
            else if(sizeof(ElementType) != 1) // if its not class type
            {
                for(int i = 0; i < m_arrayNum; i++)
                {
                    (*this)[i] = another[i];
                }
            }
            else // in another case copy the whole thing, we don't care
            {
                memcpy(&(*this)[0], &another[0], m_arrayNum * sizeof(ElementType));
            }
        }
 
        ~TDynamicAr()
        {
            Remove(0, m_arrayNum);
        }
 
        // operator overloads
 
        ElementType& operator[](sdInt i)
        {
            return ((ElementType *)m_data)[i];
        }
 
        const ElementType& operator[](sdInt i) const
        {
            return ((ElementType *)m_data)[i];
        }
 
        // concatenate with another dynamic array. e.g  arrayVar1 + arrayVar2
        TDynamicAr& operator+(const TDynamicAr& another)
        {
            if(this != &another)
            {
                for(sdInt i = 0; i < another.Count(); i++)
                {
                    new(*this)ElementType(another[i]);
                }
            }
 
            return *this;
        }
 
        TDynamicAr& operator+=(const TDynamicAr& another)
        {
            if(this != &another)
            {
                *this = *this + another;
            }
 
            return *this;
        }
 
        TDynamicAr& operator=(const TDynamicAr& another)
        {
            if(this != &another)
            {
                Empty(another.Count());
 
                for(sdInt i = 0; i < another.Count(); i++)
                {
                    new(*this)ElementType(another[i]);
                }
            }
 
            return *this;
        }
 
        // methods
 
        sdInt AddItem(const ElementType& element)
        {
            new(*this) ElementType(element);
            return Count() - 1; // return the index of the element
        }
 
        sdInt AddZeroed(sdInt count = 1)
        {
            return ParentClass::AddZeroed(sizeof(ElementType), count);
        }
 
        sdInt Add(sdInt count = 1)
        {
            return ParentClass::Add(count, sizeof(ElementType));
        }
 
        sdInt AddUnique(const ElementType& element)
        {
            for(int i = 0; i < m_arrayNum; i++)
            {
                // if its already in the array, return its index
                if((*this)[i] == element)
                {
                    return i;
                }
            }
 
            return AddItem(element);
        }
 
        sdVoid InsertItem(const ElementType& element, sdInt index)
        {
            sdInt idx = Insert(index);
            (*this)[idx] = element; // todo: debug this
        }
 
        sdVoid Insert(sdInt index, sdInt count = 1)
        {
            return ParentClass::Insert(index, count, sizeof(ElementType));
        }
 
        sdVoid InsertZeroed(sdInt index, sdInt count = 1)
        {
            return ParentClass::InsertZeroed(index, count, sizeof(ElementType));
        }
 
        ElementType Pop()
        {
            ElementType result = ((ElementType *)m_data)[m_arrayNum - 1];
            Remove(m_arrayNum - 1);
            return result;
        }
 
        ElementType& Last(sdInt c = 0)
        {
            return ((ElementType *)m_data)[m_arrayNum - count - 1];
        }
 
        const ElementType& Last(sdInt c = 0) const
        {
            return ((ElementType *)m_data)[m_arrayNum - count - 1];
        }
 
        sdVoid Shrink()
        {
            ParentClass::Shrink(sizeof(ElementType));
        }
 
        sdBool FindItem(const ElementType& item, __out sdInt& index) const
        {
            for(index = 0; index < m_arrayNum; index++)
            {
                if((*this)[index] == item)
                    return TRUE;
            }
 
            return FALSE;
        }
        sdInt FindItemIndex(const ElementType& item) const
        {
            for(sdInt index = 0; index < m_arrayNum; index++)
            {
                if((*this)[index] == item)
                    return index;
            }
 
            return INDEX_NONE;
        }
 
        sdBool Contains(const ElementType& item) const
        {
            return (FindItemIndex(item) != INDEX_NONE);
        }
 
        sdBool Remove(sdInt index, sdInt count = 1)
        {
            // if its class type, then we need to call its destructor
            if(TTypeInfo<ElementType>::IsDestructorNeeded())
            {
                for(sdInt i = index; i < index + count; i++ )
                {
                    (&(*this)[i])->~ElementType();
                }
            }
 
            return ParentClass::Remove(index, count, sizeof(ElementType));
        }
 
        sdBool Remove(const ElementType& element)
        {
            sdInt idx = FindItemIndex(element);
            return Remove(idx);
        }
 
        sdBool Empty(sdInt slack = 0)
        {
            if(TTypeInfo<ElementType>::IsDestructorNeeded())
            {
                for(sdInt i = 0; i < m_arrayNum; i++ )
                {
                    (&(*this)[i])->~ElementType();
                }
            }
 
            return ParentClass::Empty(sizeof(ElementType), slack);
        }
 
        sdVoid SwapItems(sdInt indexA, sdInt indexB)
        {
            ParentClass::Swap(indexA, indexB, sizeof(ElementType));
        }
 
        class Iterator
        {
        public:
            // constructor
            Iterator(TDynamicAr<ElementType>& inArray)
            {
                ++*this;
            }
 
            // operator overloads
 
            sdVoid operator++()
            {
                return m_array[m_index];
            }
 
            ElementType& operator*()
            {
                return m_array[m_index];
            }
 
            ElementType* operator->()
            {
                return &m_array[m_index];
            }
 
            operator sdBool() const
            {
                return m_index < m_array.Count();
            }
 
            sdVoid RemoveCurrent()
            {
                m_array.Remove(--m_index);
            }
 
            ElementType& GetCurrent() const
            {
                return m_index;
            }
 
            sdInt GetIndex() const
            {
                return m_array[m_index];
            }
 
            ElementType& GetNext() const
            {
                return m_array[m_index < m_array.Count() - 1 ? m_index + 1 : 0];
            }
            ElementType& GetPrev() const
            {
                return m_array[m_index ? m_index - 1 : m_array.Count() - 1];
            }
        private:
            TDynamicAr<ElementType>& m_array;
            sdInt m_index;
        };
 
        Iterator& GetIterator() const
        {
            if(m_iterator == NULL || !m_iterator)
            {
                m_iterator = new Iterator(this);
            }
 
            return m_iterator;
        }
    private:
        Iterator *m_iterator;
    };
 
    template<class T> sdVoid* operator new(size_t size, TDynamicAr<T>& ar)
    {
        int index = ar.CDynamicAr::Add(1, sizeof(T));
        return &ar[index];
    }
    template<class T> sdVoid* operator new(size_t size, TDynamicAr<T>& ar, sdInt index)
    {
        ar.CDynamicAr::Insert(index, 1, sizeof(T));
        return &ar[index];
    }
 
    // array exchanger
    template<class T> sdVoid ExchangeArray(TDynamicAr<T>& elemA, TDynamicAr<T>& elemB)
    {
        appMemorySwap(&elemA, &elemB, sizeof(CDynamicAr));
    }
}
#endif