HashAlgorithms.h

Go to the documentation of this file.

#ifndef MMANN_HASH_ALGORITHMS_H
#define MMANN_HASH_ALGORITHMS_H


#include "MD5Hash.h"

template <class Key>
class AHashAlgorithm
{
public:
    virtual int Hash(const Key* key) = 0;
};

template <class Key>
class SimpleHashAlgorithm : public AHashAlgorithm<Key>
{
public:
    SimpleHashAlgorithm(Key Capacity);

    virtual int Hash(const Key* key);

private:
    Key m_Capacity;
};

template <class Key>
SimpleHashAlgorithm<Key>::SimpleHashAlgorithm(Key Capacity)
{
    m_Capacity = Capacity;
}

template <class Key>
int SimpleHashAlgorithm<Key>::Hash(const Key* key)
{
    return key%m_Capacity;
}

template <class Key>
class MD5HashAlgorithm : public AHashAlgorithm<Key>
{
public:
    virtual int Hash(const Key* key);

protected:
    MD5Hash  m_MD5Hash; 
};

template <class Key>
int MD5HashAlgorithm<Key>::Hash(const Key* key)
{
    unsigned char HashValue[MD5_HASHBYTES];
    int RealHashValue;

    m_MD5Hash.Init();
    m_MD5Hash.Update((unsigned char*)key, sizeof(Key));
    m_MD5Hash.Final(HashValue);

    RealHashValue = (*(int*)HashValue);
    if (RealHashValue < 0)
    {
        // This is a bit mask that nullifies the sign bit of the
        // number so it will always be positive
        RealHashValue &= (~(1<<((sizeof(RealHashValue)<<3)-1)));
    }

    return RealHashValue;
}

template <class Key>
class PerlHashAlgorithm : public AHashAlgorithm<Key>
{
public:
    virtual int Hash(const Key* key);
};

template <class Key>
int PerlHashAlgorithm<Key>::Hash(const Key* key)
{
    int HashValue = 0;

    // Calculate the hash value for the stack
    // This hash function was ripped from the Perl source code. 
    const char * Ptr = (char*)key;
    const char * End = Ptr+key[0]+1;

    while (Ptr < End)
        HashValue += (HashValue << 5) + *(Ptr++);

    HashValue += (HashValue >> 5);

    return HashValue;
}

template <class Key, class ConfigData>
class AProcessHashAlgorithm
{
public:
    virtual int ProcessHash(Key* key, ConfigData* config) = 0;
};

template <class Key, class ConfigData>
class RemoveHashAlgorithm : public AProcessHashAlgorithm<Key, ConfigData>
{
public:
    virtual int ProcessHash(Key* key, ConfigData* config) {return 0;}
};

#endif

---