---

GXVectorArray.h

Go to the documentation of this file.

#ifndef __GXVECTORARRAY
#define __GXVECTORARRAY


#include "GXSizeableArray.h"

inline void GXBoolZeroer(bool* pBool)
{
        assert(pBool);
        *pBool=false;
}


//todo, refactor using this baby
template <typename type>
class CGXVectorArray
{
public:
        CGXVectorArray()
        {
                m_BitArray.SetInitCallback(GXBoolZeroer);
        }

        ~CGXVectorArray()
        {
                Cleanup();
        }
        
        //optional, does not need to be called
        void Cleanup()
        {
                m_ElementArray.Cleanup();
                m_BitArray.Cleanup();
        }

        inline UINT GetElementCount()
        {
                return m_ElementArray.GetElementCount();
        }


        inline void SetInitCallback(void (*pCallback)(type*))
        {
                m_ElementArray.SetInitCallback(pCallback);
        }

        inline bool GetElementAt(UINT uIndex, type* pOut)
        {
                bool bBit=m_BitArray.GetElementAt(uIndex);
                if(!bBit)
                {
                        return false;
                }

                *pOut=m_ElementArray.GetElementAt(uIndex);
                return true;
        }

        //-1 on error, else the index
        int InsertElement(type& NewElement)
        {
                UINT uCtr;

                for(uCtr=0;uCtr<m_BitArray.GetElementCount();uCtr++)
                {
                        bool bCurrentVal=m_BitArray.GetElementAt(uCtr);
                        if(!bCurrentVal)
                        {
                                if(!m_ElementArray.SetElementAt(&NewElement, uCtr))
                                {
                                        return -1;
                                }

                                bCurrentVal=true;
                                if(!m_BitArray.SetElementAt(&bCurrentVal, uCtr))
                                {
                                        return -1;
                                }
                                return (int)uCtr;       
                        }
                }

                if(!m_ElementArray.InsertElement(uCtr, NewElement))
                {
                        return -1;
                }

                bool bNewVal=true;
                if(!m_BitArray.InsertElement(uCtr, bNewVal))
                {
                        return -1;
                }

                return (int) uCtr;
        }


        bool DeleteElement(UINT uIndex)
        {
                if(uIndex>=m_ElementArray.GetElementCount())
                {
                        return false;
                }

                bool bCurrent=m_BitArray.GetElementAt(uIndex);

                if(!bCurrent)
                {
                        return false;
                }

                bCurrent=false;

                if(!m_BitArray.SetElementAt(&bCurrent, uIndex))
                {
                        return false;
                }


                return true;
        }


        bool ChangeElement(UINT uIndex, type* pIn)
        {
                bool bBit=m_BitArray.GetElementAt(uIndex);

                if(!bBit)
                {
                        return false;
                }

                return m_ElementArray.SetElementAt(pIn, uIndex);
        }
                        



private:
        CGXSizeableArray<type>  m_ElementArray;
        CGXSizeableArray<bool>  m_BitArray;

};










#endif

---