#ifndef WTF_StringHasher_h
#define WTF_StringHasher_h
#include <wtf/unicode/Unicode.h>
namespace WTF {
static const unsigned stringHashingStartValue = 0x9e3779b9U;
class StringHasher {
public:
inline StringHasher()
: m_hash(stringHashingStartValue)
, m_hasPendingCharacter(false)
, m_pendingCharacter(0)
{
}
inline void addCharacters(UChar a, UChar b)
{
ASSERT(!m_hasPendingCharacter);
addCharactersToHash(a, b);
}
inline void addCharacter(UChar ch)
{
if (m_hasPendingCharacter) {
addCharactersToHash(m_pendingCharacter, ch);
m_hasPendingCharacter = false;
return;
}
m_pendingCharacter = ch;
m_hasPendingCharacter = true;
}
inline unsigned hash() const
{
unsigned result = m_hash;
if (m_hasPendingCharacter) {
result += m_pendingCharacter;
result ^= result << 11;
result += result >> 17;
}
result ^= result << 3;
result += result >> 5;
result ^= result << 2;
result += result >> 15;
result ^= result << 10;
result &= 0x7fffffff;
if (!result)
return 0x40000000;
return result;
}
template<typename T, UChar Converter(T)> static inline unsigned computeHash(const T* data, unsigned length)
{
StringHasher hasher;
bool rem = length & 1;
length >>= 1;
while (length--) {
hasher.addCharacters(Converter(data[0]), Converter(data[1]));
data += 2;
}
if (rem)
hasher.addCharacter(Converter(*data));
return hasher.hash();
}
template<typename T, UChar Converter(T)> static inline unsigned computeHash(const T* data)
{
StringHasher hasher;
while (true) {
UChar b0 = Converter(*data++);
if (!b0)
break;
UChar b1 = Converter(*data++);
if (!b1) {
hasher.addCharacter(b0);
break;
}
hasher.addCharacters(b0, b1);
}
return hasher.hash();
}
template<typename T> static inline unsigned computeHash(const T* data, unsigned length)
{
return computeHash<T, defaultCoverter>(data, length);
}
template<typename T> static inline unsigned computeHash(const T* data)
{
return computeHash<T, defaultCoverter>(data);
}
template<size_t length> static inline unsigned hashMemory(const void* data)
{
COMPILE_ASSERT(!(length % 4), length_must_be_a_multible_of_four);
return computeHash<UChar>(static_cast<const UChar*>(data), length / sizeof(UChar));
}
static inline unsigned hashMemory(const void* data, unsigned size)
{
ASSERT(!(size % 2));
return computeHash<UChar>(static_cast<const UChar*>(data), size / sizeof(UChar));
}
private:
static inline UChar defaultCoverter(UChar ch)
{
return ch;
}
static inline UChar defaultCoverter(char ch)
{
return static_cast<unsigned char>(ch);
}
inline void addCharactersToHash(UChar a, UChar b)
{
m_hash += a;
unsigned tmp = (b << 11) ^ m_hash;
m_hash = (m_hash << 16) ^ tmp;
m_hash += m_hash >> 11;
}
unsigned m_hash;
bool m_hasPendingCharacter;
UChar m_pendingCharacter;
};
}
using WTF::StringHasher;
#endif // WTF_StringHasher_h