VC CQHashNTBuffer 牛逼的Hash表 UINT32

#pragma once

#include "Afxmt.h"

class CQHashNTNode 
{
public:
    CQHashNTNode()
    {
        m_nKeyData = 0;
        m_pValueData = NULL;
        m_nValueLength = 0;
        m_pNext = NULL;
        m_nValueSize = 0;
    }
    CQHashNTNode(UINT32 nKeyData)
    {
        m_nKeyData = nKeyData;
        m_pValueData = NULL;
        m_nValueLength = 0;
        m_pNext = NULL;
        m_nValueSize = 0;
    }
    CQHashNTNode(UINT32 nKeyData, PUINT8 pValueData, UINT32 nValueLength)
    {
        m_nKeyData = nKeyData;
        m_pValueData = NULL;
        m_nValueLength = 0;
        m_pNext = NULL;
        m_nValueSize = 0;    
        if (nValueLength > 0)
        {
            m_nValueSize = max(64, nValueLength + 32);
            m_pValueData = new UINT8[m_nValueSize];
            if (pValueData != NULL)
            {
                memcpy(m_pValueData, pValueData, nValueLength);
                m_nValueLength = nValueLength;
            }
        }
    }
    virtual ~CQHashNTNode()
    {
        if (m_pValueData != NULL)
        {
            delete[] m_pValueData;
            m_pValueData = NULL;
        }
    }
    
public:
    VOID SetValue(PUINT8 pValueData, UINT32 nValueLength)
    {
        m_nValueLength = nValueLength;
        if (m_nValueSize <= nValueLength)
        {            
            m_nValueSize = max(64, nValueLength + 32);
            delete[] m_pValueData;
            m_pValueData = new UINT8[m_nValueSize];
        }
        if (pValueData != NULL)
        {
            memcpy(m_pValueData, pValueData, nValueLength);
        }
    }
    
    VOID SetValue(UINT32 nKeyData)
    {
        m_nKeyData = nKeyData;
    }
    
    VOID GetValue(PUINT8 & pValueData, UINT32 & nValueSize, UINT32 & nValueLength)
    {
        if (pValueData == NULL)
        {
            nValueSize = m_nValueLength + 32;
            pValueData = new UINT8[nValueSize];
        }
        if (nValueSize < m_nValueLength)
        {
            delete[] pValueData;
            pValueData = NULL;
            nValueSize = m_nValueLength + 32;
            pValueData = new UINT8[nValueSize];
        }
        memcpy(pValueData, m_pValueData, m_nValueLength);
        nValueLength = m_nValueLength;
    }
    
    VOID GetValue(UINT32 & nKeyData)
    {
        nKeyData = m_nKeyData;
    }
    
    
public:
    VOID AddTailValue(UINT8 nValueByte)
    {
        if (m_pValueData == NULL)
        {
            m_nValueSize = 64;
            m_pValueData = new UINT8[m_nValueSize]; 
            m_nValueLength = 0;
        }
        else if (m_nValueLength >= m_nValueSize)
        {
            m_nValueSize = m_nValueLength + 64;
            PUINT8 pBuffer = new UINT8[m_nValueSize]; 
            memcpy(pBuffer, m_pValueData, m_nValueLength);
            delete [] m_pValueData;
            m_pValueData = pBuffer;
        }
        m_pValueData[m_nValueLength++] = nValueByte;
    }
    
    
public:
    BOOL EqualKey(UINT32 nKeyData)
    {
        return (nKeyData == m_nKeyData);
    }

public:
    UINT32 GetHashCode()
    {
        return (m_nKeyData & 0x7fffffff);
    }

public:
    static UINT32 GetHashCode(UINT32 nKeyData)
    {
        return (nKeyData & 0x7fffffff);
    }

public:
    UINT32 m_nKeyData;
    PUINT8 m_pValueData;
    UINT32 m_nValueLength;
    CQHashNTNode * m_pNext;

public:
    UINT32 m_nValueSize;
};

typedef CQHashNTNode* CQHashNTNodePtr;

class CQHashNTBuffer 
{
private:
    CQHashNTNodePtr * m_pHashTable;
    UINT32 m_nTableSize;
    UINT32 m_nNodeCount;
    UINT32 m_nCurrentIndex;
    CQHashNTNode * m_pCurrentNode;

public:
    CQHashNTBuffer()
    {
        m_nNodeCount = 0;
        m_nTableSize = 0;
        m_pHashTable = NULL;
    }
    CQHashNTBuffer(UINT32 nHashSize)
    {
        m_nNodeCount = 0;
        m_nTableSize = nHashSize;
        m_pHashTable = new CQHashNTNodePtr[nHashSize]();
        for (int x = 0; x < nHashSize; x++)
        {
            m_pHashTable[x] = NULL;
        }
    }
    virtual ~CQHashNTBuffer()
    {
        CQHashNTNode *pNode = NULL;
        CQHashNTNode *pTemp = NULL;
        for (int x = 0; x < m_nTableSize; x++)
        {
            pNode = m_pHashTable[x];
            while (pNode)
            {
                pTemp = pNode;
                pNode = pNode->m_pNext;
                delete pTemp;
            }
        }
        delete[] m_pHashTable;
    }

public:
    BOOL Lookup(UINT32 nKeyData, PUINT8 & pValueData, UINT32 & nValueSize, UINT32 & nValueLength)
    {
        BOOL bResult = FALSE;
        UINT32 nIndex = CQHashNTNode::GetHashCode(nKeyData) % m_nTableSize;
        if (m_pHashTable[nIndex] != NULL)
        {
            CQHashNTNode * pNode = m_pHashTable[nIndex];
            while (pNode)
            {
                if (pNode->EqualKey(nKeyData))
                {
                    pNode->GetValue(pValueData, nValueSize, nValueLength);
                    bResult = TRUE;
                    break;
                }
                pNode = pNode->m_pNext;
            }
        }
        return bResult;
    }
    BOOL Lookup(UINT32 nKeyData, CQHashNTNode * pValueData)
    {
        BOOL bResult = FALSE;
        UINT32 nIndex = CQHashNTNode::GetHashCode(nKeyData) % m_nTableSize;
        if (m_pHashTable[nIndex] != NULL)
        {
            CQHashNTNode * pNode = m_pHashTable[nIndex];
            while (pNode)
            {
                if (pNode->EqualKey(nKeyData))
                {
                    pNode->GetValue(pValueData->m_pValueData, pValueData->m_nValueSize, pValueData->m_nValueLength);
                    bResult = TRUE;
                    break;
                }
                pNode = pNode->m_pNext;
            }
        }
        return bResult;
    }
    BOOL Contains(UINT32 nKeyData) 
    {
        BOOL bResult = FALSE;
        UINT32 nIndex = CQHashNTNode::GetHashCode(nKeyData) % m_nTableSize;
        if (m_pHashTable[nIndex] != NULL)
        {
            CQHashNTNode * pNode = m_pHashTable[nIndex];
            while (pNode)
            {
                if (pNode->EqualKey(nKeyData))
                {
                    bResult = TRUE;
                    break;
                }
                pNode = pNode->m_pNext;
            }
        }
        return bResult;
    }
    VOID SetAt(UINT32 nKeyData, PUINT8 pValueData, UINT32 nValueLength)
    {
        UINT32 nIndex = CQHashNTNode::GetHashCode(nKeyData) % m_nTableSize;
        if (m_pHashTable[nIndex] != NULL)
        {            
            BOOL bFind = FALSE;
            CQHashNTNode * pNode = m_pHashTable[nIndex];
            while (pNode)
            {
                if (pNode->EqualKey(nKeyData))
                {
                    pNode->SetValue(pValueData, nValueLength);
                    bFind = TRUE;
                    break;
                }
                pNode = pNode->m_pNext;
            }
            if (!bFind)
            {
                pNode = new CQHashNTNode(nKeyData, pValueData, nValueLength);
                pNode->m_pNext = m_pHashTable[nIndex];
                m_pHashTable[nIndex] = pNode;
                m_nNodeCount += 1;
            }
        }
        else
        {
            CQHashNTNode * pNode = new CQHashNTNode(nKeyData, pValueData, nValueLength);
            pNode->m_pNext = m_pHashTable[nIndex];
            m_pHashTable[nIndex] = pNode;
            m_nNodeCount += 1;
        }
    }
    VOID Remove(UINT32 nKeyData)
    {
        UINT32 nIndex = CQHashNTNode::GetHashCode(nKeyData) % m_nTableSize;
        if (m_pHashTable[nIndex] != NULL)
        {
            CQHashNTNode * pNode = m_pHashTable[nIndex];
            CQHashNTNode * pPrev = NULL;
            while (pNode != NULL)
            {
                if (pNode->EqualKey(nKeyData))
                {
                    if (pPrev == NULL)
                    {
                        m_pHashTable[nIndex] = pNode->m_pNext;
                    }
                    else 
                    {
                        pPrev->m_pNext = pNode->m_pNext;
                    }
                    delete pNode;
                    m_nNodeCount -= 1;
                    break;
                }
                pNode = pNode->m_pNext;
            }
        }
    }
    VOID RemoveAll()
    {
        for (UINT32 n = 0; n < m_nTableSize; n++)
        {
            if (m_pHashTable[n] != NULL)
            {
                CQHashNTNode * pNode = m_pHashTable[n];
                while (pNode)
                {
                    m_pHashTable[n] = pNode->m_pNext;
                    delete pNode;
                    pNode = m_pHashTable[n];
                }
            }
        }
        m_nNodeCount = 0;
    }
    UINT32 GetCount()
    {
        return m_nNodeCount;
    }
public:
    CQHashNTNode * GetHead()
    {
        m_nCurrentIndex = 0;
        m_pCurrentNode = NULL;
        for (UINT32 n = 0; n < m_nTableSize; n++)
        {
            if (m_pHashTable[n] != NULL)
            {
                m_nCurrentIndex = n;
                m_pCurrentNode = m_pHashTable[n];
                break;
            }
        }
        return m_pCurrentNode;
    }
    CQHashNTNode * GetNext()
    {
        if (m_pCurrentNode != NULL)
        {
            if (m_pCurrentNode->m_pNext != NULL)
            {
                m_pCurrentNode = m_pCurrentNode->m_pNext;
            }
            else 
            {
                for (UINT32 n = m_nCurrentIndex; n < m_nTableSize; n++)
                {
                    if (m_pHashTable[n] != NULL)
                    {
                        m_nCurrentIndex = n;
                        m_pCurrentNode = m_pHashTable[n];
                        break;
                    }
                }
            }
        }
        return m_pCurrentNode;
    }
};