source-engine/gcsdk/steamextra/tier1/pearsonshash.h

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:	PearsonsHash.h
//
//	This file contains implementation definitions of 'Pearson's' Hash'
//	The generic implementation is a template, plus a couple of specializations
//	for commonly used types.
//
//	Take a look at http://en.wikipedia.org/wiki/Pearson_hashing for more info.
//
//=============================================================================

#ifndef _PEARSONSHASH_H_
#define	_PEARSONSHASH_H_

#if defined(_WIN32) || defined(_WIN64)
#pragma once
#endif

extern const unsigned char g_CTHashRandomValues[256] ; 

template<typename T> 
struct PearsonsHashFunctor
{
	typedef	uint32  TargetType ; 
	TargetType	operator()(const T& unKey) const
	{
		// This is a pearsons hash variant that returns a maximum of 32 bits
		size_t size = sizeof(T);
		const uint8 *	k    = (const uint8 *) &unKey;
		uint32 byte_one = 0, byte_two = 0, byte_three = 0, byte_four = 0, n;
		while (size)
		{
			--size;
			n    = *k++;
			byte_one = g_CTHashRandomValues[byte_one ^ n];

			if (size)
			{
				--size;
				n   = *k++;
				byte_two = g_CTHashRandomValues[byte_two ^ n];
			}
			else
				break;

			if (size)
			{
				--size;
				n   = *k++;
				byte_three = g_CTHashRandomValues[byte_three ^ n];
			}
			else
				break;

			if (size)
			{
				--size;
				n   = *k++;
				byte_four = g_CTHashRandomValues[byte_four ^ n];
			}
			else
				break;
		}

		TargetType idx = ( byte_four << 24 ) | ( byte_three << 16 ) | ( byte_two << 8 ) | byte_one;
		return ( idx ); 
	}
};

//
//	We use this specialization for pointer types - it allows somebody 
//	to define a specialization for some complicated type, and then use a 
//	pointer to that type as a key, and have that automatically go to the 
//	specialization for the complicated type !
//
template<typename T>
struct PearsonsHashFunctor<T*>	
{
	typedef	uint32	TargetType ; 
	TargetType operator()(const T* key) const 
	{
		PearsonsHashFunctor<T>	functor ; 
		return functor(*key) ; 
	}
};

//
//	This functor specializes for unsigned 32 bit integers, a commonly used type in Steam.
//	It should return the exact same result as the unspecialized version on Intel Architecture machines.
//
template<>
struct PearsonsHashFunctor<uint32>
{
	typedef	uint32 TargetType ; 
	TargetType	operator()(const uint32 unKey) const
	{
		uint32 byte_one =	g_CTHashRandomValues[(unKey>>0) & 0xff];
		uint32 byte_two =	g_CTHashRandomValues[(unKey>>8) & 0xff];
		uint32 byte_three = g_CTHashRandomValues[(unKey>>16) & 0xff];
		uint32 byte_four =	g_CTHashRandomValues[(unKey>>24)&0xff];
		return	( byte_four << 24 ) | ( byte_three << 16 ) | ( byte_two << 8 ) | byte_one; 
	}
};

//
//	This functor specializes for unsigned 64 bit integers, another commonly used type in Steam.
//	It should return the exact same result as the unspecialized version on Intel Architecture machines.
//
template<>
struct PearsonsHashFunctor<uint64>
{
	typedef	uint32 TargetType ; 
	TargetType	operator()(const uint64 unKey) const
	{
		//
		//	Note that we pull apart the 64 bits in Intel's endian order.
		//
		uint32 n; 
		//
		//	On Intel Machines, to make this return the exact same result as the generic version 
		//	we have to go from least significant byte to most significant byte ! 
		//
		n = static_cast<uint32>((unKey >> (0)) & 0xff)  ; 
		uint32 byte_one =	g_CTHashRandomValues[n];
		n = static_cast<uint32>((unKey >> (8)) & 0xff) ; 
		uint32 byte_two =	g_CTHashRandomValues[n];
		n = static_cast<uint32>((unKey >> (16)) & 0xff) ; 
		uint32 byte_three = g_CTHashRandomValues[n];
		n = static_cast<uint32>((unKey >> (24)) & 0xff)  ; 		
		uint32 byte_four =	g_CTHashRandomValues[n];
		n = static_cast<uint32>((unKey >> (32)) & 0xff)  ; 
		byte_one =			g_CTHashRandomValues[n ^ byte_one];
		n = static_cast<uint32>((unKey >> (8+32)) & 0xff)  ; 
		byte_two =			g_CTHashRandomValues[n ^ byte_two];
		n = static_cast<uint32>((unKey >> (16+32)) & 0xff)  ; 
		byte_three =		g_CTHashRandomValues[n ^ byte_three];
		n = static_cast<uint32>((unKey >> (24+32)) & 0xff)  ; 
		byte_four =			g_CTHashRandomValues[n ^ byte_four];
		return	( byte_four << 24 ) | ( byte_three << 16 ) | ( byte_two << 8 ) | byte_one; 
	}
};

//
//	This functor specializes for C standard NULL terminated strings !
//	It is setup so that if you had a char array containing a NULL terminated string
//	and correctly sized, ie char rgch[16] = { "123456789012345" } and a 
//	null terminated string i.e. char *sz = "123456789012345" these will return identical
//	results, and both include the NULL terminator in the hash calculation.
//
template<>
struct PearsonsHashFunctor<char*>
{
	typedef	uint32  TargetType ; 
	TargetType	operator()(const char* szKey) const
	{
		const uint8 *	k    = (const uint8 *) szKey ;
		uint32 byte_one = 0, byte_two = 0, byte_three = 0, byte_four = 0, n;
		do
		{
			n    = *k++;
			byte_one = g_CTHashRandomValues[byte_one ^ n];
			if (n=='\0')
				break;

			n   = *k++;
			byte_two = g_CTHashRandomValues[byte_two ^ n];
			if (n=='\0')
				break;

			n   = *k++;
			byte_three = g_CTHashRandomValues[byte_three ^ n];
			if (n=='\0')
				break;

			n   = *k++;
			byte_four = g_CTHashRandomValues[byte_four ^ n];
		}	while(n!='\0') ; 

		TargetType idx = ( byte_four << 24 ) | ( byte_three << 16 ) | ( byte_two << 8 ) | byte_one;
		return ( idx ); 
	}
};

//
//	This functor compares two objects of a particular type and returns a result
//	that follows the strcmp/memcmp.
//	If the type doesn't provide an operator== or operator< then you can provide 
//	a type specific specialization to override this defualt functor !
//
template<typename T>
struct	ComparisonFunctor
{
	int	operator()(const T &lhs, const T &rhs) const 
	{
		if( lhs == rhs ) 
			return 0 ; 
		else if( lhs < rhs ) 
			return -1 ; 
		else 
			return 1 ; 
	}

};

//
//	I expect people to build Comparison specializations for full types, 
//	not pointer types - this Specialization should allow the C++ compiler
//	to bind to a specialization for a particular type.
//	We do not want to compare pointers for equality, and a memcmp() may 
//	not be good for a complicated type !
//
template<typename T>
struct ComparisonFunctor<T*>
{
	int operator()(const T *lhs, const T *rhs) const 
	{
		ComparisonFunctor<T>	functor ; 
		return functor(*lhs, *rhs) ; 
	}
};

template<>
struct ComparisonFunctor<int>
{
	int		operator()(const int lhs, const int rhs) const
	{
		return lhs-rhs ; 
	}
};

template<>
struct ComparisonFunctor<unsigned int>
{
	int		operator()(const unsigned int lhs, const unsigned int rhs) const 
	{
		return static_cast<int>(lhs) - static_cast<int>(rhs) ; 
	}
};


template<>
struct ComparisonFunctor<uint64>
{
	int		operator()(const uint64 lhs, const uint64 rhs) const 
	{
		if( lhs < rhs ) 
			return -1 ; 
		else if( lhs == rhs ) 
			return 0 ;
		else
			return 1 ; 
	}
};

template<>
struct ComparisonFunctor<char*>
{
	int		operator()(const char * lhs, const char* rhs) const 
	{
		return	Q_strcmp(lhs, rhs) ; 
	}
};


#endif // _PEARSONSHASH_H_