402 lines
13 KiB
C++
402 lines
13 KiB
C++
/*
|
|
Copyright (C) 2001-2006, William Joseph.
|
|
All Rights Reserved.
|
|
|
|
This file is part of GtkRadiant.
|
|
|
|
GtkRadiant is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
GtkRadiant is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GtkRadiant; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#if !defined( INCLUDED_CONTAINER_HASHFUNC_H )
|
|
#define INCLUDED_CONTAINER_HASHFUNC_H
|
|
|
|
#include <cctype>
|
|
#include "string/string.h"
|
|
#include "container/array.h"
|
|
typedef unsigned long int ub4; /* unsigned 4-byte quantities */
|
|
typedef unsigned char ub1;
|
|
|
|
inline ub1 ub1_as_ub1_nocase( ub1 byte ){
|
|
return std::tolower( byte );
|
|
}
|
|
|
|
inline ub4 ub1x4_as_ub4_nocase( const ub1 bytes[4] ){
|
|
ub4 result;
|
|
reinterpret_cast<ub1*>( &result )[0] = ub1_as_ub1_nocase( bytes[0] );
|
|
reinterpret_cast<ub1*>( &result )[1] = ub1_as_ub1_nocase( bytes[1] );
|
|
reinterpret_cast<ub1*>( &result )[2] = ub1_as_ub1_nocase( bytes[2] );
|
|
reinterpret_cast<ub1*>( &result )[3] = ub1_as_ub1_nocase( bytes[3] );
|
|
return result;
|
|
}
|
|
|
|
class ub1_default_traits
|
|
{
|
|
public:
|
|
static ub1 as_ub1( ub1 byte ){
|
|
return byte;
|
|
}
|
|
};
|
|
|
|
class ub1_nocase_traits
|
|
{
|
|
public:
|
|
static ub1 as_ub1( ub1 byte ){
|
|
return ub1_as_ub1_nocase( byte );
|
|
}
|
|
};
|
|
|
|
class ub1x4_default_traits
|
|
{
|
|
public:
|
|
static ub4 as_ub4( const ub1 bytes[4] ){
|
|
return *reinterpret_cast<const ub4*>( bytes );
|
|
}
|
|
};
|
|
|
|
class ub1x4_nocase_traits
|
|
{
|
|
public:
|
|
static ub4 as_ub4( const ub1 bytes[4] ){
|
|
return ub1x4_as_ub4_nocase( bytes );
|
|
}
|
|
};
|
|
|
|
class ub4_default_traits
|
|
{
|
|
public:
|
|
static ub4 as_ub4( ub4 i ){
|
|
return i;
|
|
}
|
|
};
|
|
|
|
class ub4_nocase_traits
|
|
{
|
|
public:
|
|
static ub4 as_ub4( ub4 i ){
|
|
return ub1x4_as_ub4_nocase( reinterpret_cast<const ub1*>( &i ) );
|
|
}
|
|
};
|
|
|
|
// lookup2.c
|
|
// By Bob Jenkins, 1996. bob_jenkins@burtleburtle.net. You may use this
|
|
// code any way you wish, private, educational, or commercial. It's free.
|
|
|
|
#define hashsize( n ) ( (ub4)1 << ( n ) )
|
|
#define hashmask( n ) ( hashsize( n ) - 1 )
|
|
|
|
/*
|
|
--------------------------------------------------------------------
|
|
mix -- mix 3 32-bit values reversibly.
|
|
For every delta with one or two bit set, and the deltas of all three
|
|
high bits or all three low bits, whether the original value of a,b,c
|
|
is almost all zero or is uniformly distributed,
|
|
* If mix() is run forward or backward, at least 32 bits in a,b,c
|
|
have at least 1/4 probability of changing.
|
|
* If mix() is run forward, every bit of c will change between 1/3 and
|
|
2/3 of the time. (Well, 22/100 and 78/100 for some 2-bit deltas.)
|
|
mix() was built out of 36 single-cycle latency instructions in a
|
|
structure that could supported 2x parallelism, like so:
|
|
a -= b;
|
|
a -= c; x = (c>>13);
|
|
b -= c; a ^= x;
|
|
b -= a; x = (a<<8);
|
|
c -= a; b ^= x;
|
|
c -= b; x = (b>>13);
|
|
...
|
|
Unfortunately, superscalar Pentiums and Sparcs can't take advantage
|
|
of that parallelism. They've also turned some of those single-cycle
|
|
latency instructions into multi-cycle latency instructions. Still,
|
|
this is the fastest good hash I could find. There were about 2^^68
|
|
to choose from. I only looked at a billion or so.
|
|
--------------------------------------------------------------------
|
|
*/
|
|
#define mix( a,b,c ) \
|
|
{ \
|
|
a -= b; a -= c; a ^= ( c >> 13 ); \
|
|
b -= c; b -= a; b ^= ( a << 8 ); \
|
|
c -= a; c -= b; c ^= ( b >> 13 ); \
|
|
a -= b; a -= c; a ^= ( c >> 12 ); \
|
|
b -= c; b -= a; b ^= ( a << 16 ); \
|
|
c -= a; c -= b; c ^= ( b >> 5 ); \
|
|
a -= b; a -= c; a ^= ( c >> 3 ); \
|
|
b -= c; b -= a; b ^= ( a << 10 ); \
|
|
c -= a; c -= b; c ^= ( b >> 15 ); \
|
|
}
|
|
|
|
/* same, but slower, works on systems that might have 8 byte ub4's */
|
|
#define mix2( a,b,c ) \
|
|
{ \
|
|
a -= b; a -= c; a ^= ( c >> 13 ); \
|
|
b -= c; b -= a; b ^= ( a << 8 ); \
|
|
c -= a; c -= b; c ^= ( ( b & 0xffffffff ) >> 13 ); \
|
|
a -= b; a -= c; a ^= ( ( c & 0xffffffff ) >> 12 ); \
|
|
b -= c; b -= a; b = ( b ^ ( a << 16 ) ) & 0xffffffff; \
|
|
c -= a; c -= b; c = ( c ^ ( b >> 5 ) ) & 0xffffffff; \
|
|
a -= b; a -= c; a = ( a ^ ( c >> 3 ) ) & 0xffffffff; \
|
|
b -= c; b -= a; b = ( b ^ ( a << 10 ) ) & 0xffffffff; \
|
|
c -= a; c -= b; c = ( c ^ ( b >> 15 ) ) & 0xffffffff; \
|
|
}
|
|
|
|
/*
|
|
--------------------------------------------------------------------
|
|
hash() -- hash a variable-length key into a 32-bit value
|
|
k : the key (the unaligned variable-length array of bytes)
|
|
len : the length of the key, counting by bytes
|
|
level : can be any 4-byte value
|
|
Returns a 32-bit value. Every bit of the key affects every bit of
|
|
the return value. Every 1-bit and 2-bit delta achieves avalanche.
|
|
About 36+6len instructions.
|
|
|
|
The best hash table sizes are powers of 2. There is no need to do
|
|
mod a prime (mod is sooo slow!). If you need less than 32 bits,
|
|
use a bitmask. For example, if you need only 10 bits, do
|
|
h = (h & hashmask(10));
|
|
In which case, the hash table should have hashsize(10) elements.
|
|
|
|
If you are hashing n strings (ub1 **)k, do it like this:
|
|
for (i=0, h=0; i<n; ++i) h = hash( k[i], len[i], h);
|
|
|
|
See http://burlteburtle.net/bob/hash/evahash.html
|
|
Use for hash table lookup, or anything where one collision in 2^32 is
|
|
acceptable. Do NOT use for cryptographic purposes.
|
|
--------------------------------------------------------------------
|
|
*/
|
|
|
|
template<typename UB1Traits, typename UB4x1Traits>
|
|
inline ub4 hash(
|
|
const ub1 *k, /* the key */
|
|
ub4 length, /* the length of the key */
|
|
ub4 initval, /* the previous hash, or an arbitrary value */
|
|
const UB1Traits& ub1traits,
|
|
const UB4x1Traits& ub4x1traits
|
|
){
|
|
register ub4 a,b,c,len;
|
|
|
|
/* Set up the internal state */
|
|
len = length;
|
|
a = b = 0x9e3779b9; /* the golden ratio; an arbitrary value */
|
|
c = initval; /* the previous hash value */
|
|
|
|
/*---------------------------------------- handle most of the key */
|
|
while ( len >= 12 )
|
|
{
|
|
a += ( k[0] + ( ( ub4 ) UB1Traits::as_ub1( k[1] ) << 8 ) + ( ( ub4 ) UB1Traits::as_ub1( k[2] ) << 16 ) + ( ( ub4 ) UB1Traits::as_ub1( k[3] ) << 24 ) );
|
|
b += ( k[4] + ( ( ub4 ) UB1Traits::as_ub1( k[5] ) << 8 ) + ( ( ub4 ) UB1Traits::as_ub1( k[6] ) << 16 ) + ( ( ub4 ) UB1Traits::as_ub1( k[7] ) << 24 ) );
|
|
c += ( k[8] + ( ( ub4 ) UB1Traits::as_ub1( k[9] ) << 8 ) + ( ( ub4 ) UB1Traits::as_ub1( k[10] ) << 16 ) + ( ( ub4 ) UB1Traits::as_ub1( k[11] ) << 24 ) );
|
|
mix( a,b,c );
|
|
k += 12; len -= 12;
|
|
}
|
|
|
|
/*------------------------------------- handle the last 11 bytes */
|
|
c += length;
|
|
switch ( len ) /* all the case statements fall through */
|
|
{
|
|
case 11: c += ( ( ub4 ) UB1Traits::as_ub1( k[10] ) << 24 );
|
|
case 10: c += ( ( ub4 ) UB1Traits::as_ub1( k[9] ) << 16 );
|
|
case 9: c += ( ( ub4 ) UB1Traits::as_ub1( k[8] ) << 8 );
|
|
/* the first byte of c is reserved for the length */
|
|
case 8: b += ( ( ub4 ) UB1Traits::as_ub1( k[7] ) << 24 );
|
|
case 7: b += ( ( ub4 ) UB1Traits::as_ub1( k[6] ) << 16 );
|
|
case 6: b += ( ( ub4 ) UB1Traits::as_ub1( k[5] ) << 8 );
|
|
case 5: b += UB1Traits::as_ub1( k[4] );
|
|
case 4: a += ( ( ub4 ) UB1Traits::as_ub1( k[3] ) << 24 );
|
|
case 3: a += ( ( ub4 ) UB1Traits::as_ub1( k[2] ) << 16 );
|
|
case 2: a += ( ( ub4 ) UB1Traits::as_ub1( k[1] ) << 8 );
|
|
case 1: a += UB1Traits::as_ub1( k[0] );
|
|
/* case 0: nothing left to add */
|
|
}
|
|
mix( a,b,c );
|
|
/*-------------------------------------------- report the result */
|
|
return c;
|
|
}
|
|
|
|
/*
|
|
--------------------------------------------------------------------
|
|
This works on all machines. hash2() is identical to hash() on
|
|
little-endian machines, except that the length has to be measured
|
|
in ub4s instead of bytes. It is much faster than hash(). It
|
|
requires
|
|
-- that the key be an array of ub4's, and
|
|
-- that all your machines have the same endianness, and
|
|
-- that the length be the number of ub4's in the key
|
|
--------------------------------------------------------------------
|
|
*/
|
|
template<typename UB4Traits>
|
|
inline ub4 hash2(
|
|
const ub4 *k, /* the key */
|
|
ub4 length, /* the length of the key, in ub4s */
|
|
ub4 initval, /* the previous hash, or an arbitrary value */
|
|
const UB4Traits& ub4traits
|
|
){
|
|
register ub4 a,b,c,len;
|
|
|
|
/* Set up the internal state */
|
|
len = length;
|
|
a = b = 0x9e3779b9; /* the golden ratio; an arbitrary value */
|
|
c = initval; /* the previous hash value */
|
|
|
|
/*---------------------------------------- handle most of the key */
|
|
while ( len >= 3 )
|
|
{
|
|
a += UB4Traits::as_ub4( k[0] );
|
|
b += UB4Traits::as_ub4( k[1] );
|
|
c += UB4Traits::as_ub4( k[2] );
|
|
mix( a,b,c );
|
|
k += 3; len -= 3;
|
|
}
|
|
|
|
/*-------------------------------------- handle the last 2 ub4's */
|
|
c += length;
|
|
switch ( len ) /* all the case statements fall through */
|
|
{
|
|
/* c is reserved for the length */
|
|
case 2: b += UB4Traits::as_ub4( k[1] );
|
|
case 1: a += UB4Traits::as_ub4( k[0] );
|
|
/* case 0: nothing left to add */
|
|
}
|
|
mix( a,b,c );
|
|
/*-------------------------------------------- report the result */
|
|
return c;
|
|
}
|
|
|
|
typedef ub4 hash_t;
|
|
|
|
inline hash_t hash_ub1( const ub1* key, std::size_t len, hash_t previous = 0 ){
|
|
return hash( key, ub4( len ), previous, ub1_default_traits(), ub1x4_default_traits() );
|
|
}
|
|
|
|
inline hash_t hash_ub1_nocase( const ub1* key, std::size_t len, hash_t previous = 0 ){
|
|
return hash( key, ub4( len ), previous, ub1_nocase_traits(), ub1x4_nocase_traits() );
|
|
}
|
|
|
|
template<typename UB4Traits>
|
|
inline hash_t hash_ub4( const ub4* key, std::size_t len, const UB4Traits& traits, hash_t previous = 0 ){
|
|
return hash2( key,ub4( len ), previous, traits );
|
|
}
|
|
|
|
inline ub4 hash_combine( ub4 left, ub4 right ){
|
|
return hash_ub1( reinterpret_cast<const ub1*>( &left ), 4, right );
|
|
}
|
|
|
|
template<typename POD>
|
|
inline hash_t pod_hash( const POD& pod ){
|
|
return hash_ub1( reinterpret_cast<const ub1*>( &pod ), sizeof( POD ) );
|
|
}
|
|
|
|
inline hash_t string_hash( const char* string, hash_t previous = 0 ){
|
|
return hash_ub1( reinterpret_cast<const ub1*>( string ), string_length( string ), previous );
|
|
}
|
|
|
|
inline hash_t string_hash_nocase( const char* string, hash_t previous = 0 ){
|
|
return hash_ub1_nocase( reinterpret_cast<const ub1*>( string ), string_length( string ), previous );
|
|
}
|
|
|
|
struct RawStringHash
|
|
{
|
|
typedef hash_t hash_type;
|
|
hash_type operator()( const char* string ) const {
|
|
return string_hash( string );
|
|
}
|
|
};
|
|
|
|
struct HashString
|
|
{
|
|
typedef hash_t hash_type;
|
|
hash_type operator()( const CopiedString& string ) const {
|
|
return string_hash( string.c_str() );
|
|
}
|
|
};
|
|
|
|
struct HashStringNoCase
|
|
{
|
|
typedef hash_t hash_type;
|
|
hash_type operator()( const CopiedString& string ) const {
|
|
return string_hash_nocase( string.c_str() );
|
|
}
|
|
};
|
|
|
|
/// \brief Length of a string in ub4.
|
|
/// "wibble" (6) gives 2,
|
|
/// "and" (3) gives 1,
|
|
/// "bleh" (4) gives 2
|
|
inline std::size_t string_length_ub4( const char* string ){
|
|
return ( ( string_length( string ) >> 2 ) + 1 ) << 2;
|
|
}
|
|
|
|
/// \brief Hashable key type that stores a string as an array of ub4 - making hashing faster.
|
|
/// Also caches the 32-bit result of the hash to speed up comparison of keys.
|
|
template<typename UB4Traits = ub4_default_traits>
|
|
class HashKey
|
|
{
|
|
Array<ub4> m_key;
|
|
hash_t m_hash;
|
|
|
|
void copy( const HashKey& other ){
|
|
std::copy( other.m_key.begin(), other.m_key.end(), m_key.begin() );
|
|
m_hash = other.m_hash;
|
|
}
|
|
void copy( const char* string ){
|
|
strncpy( reinterpret_cast<char*>( m_key.data() ), string, m_key.size() );
|
|
for ( Array<ub4>::iterator i = m_key.begin(); i != m_key.end(); ++i )
|
|
{
|
|
*i = UB4Traits::as_ub4( *i );
|
|
}
|
|
m_hash = hash_ub4( m_key.data(), m_key.size(), ub4_default_traits() );
|
|
}
|
|
bool equal( const HashKey& other ) const {
|
|
return m_hash == other.m_hash && m_key.size() == other.m_key.size()
|
|
&& std::equal( m_key.begin(), m_key.end(), other.m_key.begin() );
|
|
}
|
|
|
|
public:
|
|
HashKey( const HashKey& other ) : m_key( other.m_key.size() ){
|
|
copy( other );
|
|
}
|
|
HashKey( const char* string ) : m_key( string_length_ub4( string ) ){
|
|
copy( string );
|
|
}
|
|
HashKey& operator=( const char* string ){
|
|
m_key.resize( string_length_ub4( string ) );
|
|
copy( string );
|
|
return *this;
|
|
}
|
|
bool operator==( const HashKey& other ) const {
|
|
return equal( other );
|
|
}
|
|
bool operator!=( const HashKey& other ) const {
|
|
return !equal( other );
|
|
}
|
|
hash_t hash() const {
|
|
return m_hash;
|
|
}
|
|
#if 0
|
|
const char* c_str() const {
|
|
return reinterpret_cast<const char*>( m_key.data() );
|
|
}
|
|
#endif
|
|
};
|
|
|
|
/// \brief Hash function to use with HashKey.
|
|
struct HashKeyHasher
|
|
{
|
|
typedef hash_t hash_type;
|
|
hash_type operator()( const HashKey<ub4_default_traits>& key ) const {
|
|
return key.hash();
|
|
}
|
|
};
|
|
|
|
|
|
|
|
#endif
|