---

GXHashTable.h

Go to the documentation of this file.

#ifndef __GXHASHTABLE
#define __GXHASHTABLE


#include "GXStandardDefines.h"
#include "GXPrimitiveLL.h"
#include "GXAutoArray.h"


//type must support a .HashCode() function (returns a UINT)
//type must support bool .Assign(type&) function

template<typename type>
class CGXHashTable
{
public:
        CGXHashTable()
        {
                m_uIteratorIndex=0;
        }

        ~CGXHashTable()
        {
        }


        bool Init(UINT uHashSize)
        {
                assert(0!=uHashSize);

                if(!m_Lists.Init(uHashSize))
                {
                        return false;
                }

                return true;
        }


        bool AddElement(type* pIn)
        {
                assert(pIn!=NULL);
                assert(m_Lists.GetCount()!=0);

                UINT uHashIndex=(pIn->HashCode()) % (m_Lists.GetCount());

                //see if it is already in the list
                CGXPrimitiveLL<type>* pTargetList=&(m_Lists.GetPtr()[uHashIndex]);

                for (pTargetList->IteratorFirst(); pTargetList->IteratorHasMore(); )
                {
                        type Next;
                        if(!pTargetList->IteratorNext(&Next))
                        {
                                return false;
                        }

                        if(*pIn==Next)
                        {
                                return true;
                        }
                }

                //It's not in list
                if(!m_Lists.GetPtr()[uHashIndex].AddElement(pIn))
                {
                        return false;
                }

                return true;
        }

        bool GetElement(type* pOut)
        {
                UINT uHashIndex=(pOut->HashCode()) % (m_Lists.GetCount());
                
                CGXPrimitiveLL<type>* pTargetList=&(m_Lists.GetPtr()[uHashIndex]);

                //linear search to see if it is in list
                for (pTargetList->IteratorFirst(); pTargetList->IteratorHasMore(); )
                {
                        type Next;
                        if(!pTargetList->IteratorNext(&Next))
                        {
                                return false;
                        }

                        if(*pOut==Next)
                        {
                                if(!pOut->Assign(Next))
                                {
                                        return false;
                                }

                                return true;
                        }
                }
                return false;
        }




        void IteratorFirst()
        {
                m_uIteratorIndex=0;
                if(m_Lists.GetCount()>0)
                {
                        m_Lists.GetPtr()[m_uIteratorIndex].IteratorFirst();
                }
        }

        bool IteratorHasMore()
        {
                if(m_uIteratorIndex>=m_Lists.GetCount())
                {
                        return false;
                }

                if(!m_Lists.GetPtr()[m_uIteratorIndex].IteratorHasMore())
                {
                        m_uIteratorIndex++;
                        return IteratorHasMore();
                }

                return true;
        }

        bool IteratorNext(type* pOut)
        {
                assert(pOut!=NULL);

                if(!IteratorHasMore())
                {
                        return false;
                }

                return m_Lists.GetPtr()[m_uIteratorIndex].IteratorNext(pOut);
        }





protected:
        CGXAutoArray< CGXPrimitiveLL<type> >    m_Lists;
        UINT                                                                    m_uIteratorIndex;
};



#endif

---