Initial commit

neo/idlib/containers/HashTable.h

@@ -0,0 +1,897 @@
+/*
+===========================================================================
+
+Doom 3 BFG Edition GPL Source Code
+Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company. 
+
+This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").  
+
+Doom 3 BFG Edition Source Code 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 3 of the License, or
+(at your option) any later version.
+
+Doom 3 BFG Edition Source Code 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 Doom 3 BFG Edition Source Code.  If not, see <http://www.gnu.org/licenses/>.
+
+In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code.  If not, please request a copy in writing from id Software at the address below.
+
+If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
+
+===========================================================================
+*/
+
+#ifndef __HASHTABLE_H__
+#define __HASHTABLE_H__
+
+/*
+================================================================================================
+idHashNodeT is a generic node for a HashTable. It is specialized by the 
+StringHashNode and CStringHashNode template classes.
+================================================================================================
+*/
+template< typename _key_, class _value_ > 
+class idHashNodeT {
+public:
+	idHashNodeT() 
+		:	next( NULL ) {
+	}
+
+	idHashNodeT( const _key_ & key, const _value_ & value, idHashNodeT * next )
+		:	key( key ),
+		value( value ),
+		next( next ) {
+	}
+
+	static int	GetHash( const _key_ & key, const int tableMask ) {
+		return key & tableMask;
+	}
+
+	static int	Compare( const _key_ & key1, const _key_ & key2 ) {
+		if ( key1 < key2 ) {
+			return -1;
+		} else if ( key1 > key2 ) {
+			return 1;
+		}
+		return 0;
+	}
+
+public:
+	_key_							key;
+	_value_							value;
+	idHashNodeT< _key_, _value_ > *	next;
+};
+
+/*
+================================================
+idHashNodeT is a HashNode that provides for partial 
+specialization for the HashTable, allowing the String class's Cmp function to be used 
+for inserting values in sorted order.
+================================================
+*/
+template< class _value_ >
+class idHashNodeT< idStr, _value_ > {
+public:
+	idHashNodeT( const idStr & key, const _value_ & value, idHashNodeT * next )
+		:	key( key ),
+		value( value ),
+		next( next ) {
+	}
+
+	static int	GetHash( const idStr & key, const int tableMask ) {
+		return ( idStr::Hash( key ) & tableMask );
+	}
+
+	static int	Compare( const idStr & key1, const idStr & key2 ) {
+		return idStr::Icmp( key1, key2 );
+	}
+
+public:
+	idStr							key;
+	_value_							value;
+	idHashNodeT< idStr, _value_ > *	next;
+};
+
+/*
+================================================
+idHashNodeT is a HashNode that provides for a partial specialization 
+for the HashTable, allowing the String class's Cmp function to 
+be used for inserting values in sorted order. It also ensures that a copy of the the key is 
+stored in a String (to more closely model the original implementation of the HashTable).
+================================================
+*/
+template< class _value_ >
+class idHashNodeT< const char*, _value_ > {
+public:
+	idHashNodeT( const char* const & key, const _value_ & value, idHashNodeT * next )
+		:	key( key ),
+		value( value ),
+		next( next ) {
+	} 
+
+	static int	GetHash( const char* const & key, const int tableMask ) {
+		return ( idStr::Hash( key ) & tableMask );
+	}
+
+	static int	Compare( const char* const & key1, const char* const & key2 ) {
+		return idStr::Icmp( key1, key2 );
+	}
+
+public:
+	idStr									key;	// char * keys must still get stored in an idStr
+	_value_									value;
+	idHashNodeT< const char *, _value_ > *	next;
+};
+
+/*
+================================================
+idHashTableT is a general implementation of a hash table data type. It is
+slower than the HashIndex, but it can also be used for LinkedLists and other data structures,
+rather than just indexes and arrays. 
+
+It uses an arbitrary key type. For String keys, use the StringHashTable template 
+specialization.
+================================================
+*/
+template< typename _key_, class _value_ >
+class idHashTableT {
+public:
+	idHashTableT( const int tableSize = 256 );
+	idHashTableT( const idHashTableT & other );
+	~idHashTableT();
+
+	size_t			Allocated() const;
+	size_t			Size() const;
+
+	_value_ &		Set( const _key_ & key, const _value_ & value );
+
+	bool			Get( const _key_ & key, _value_ ** value = NULL );
+	bool			Get( const _key_ & key, const _value_ ** value = NULL ) const;
+
+	bool			Remove( const _key_ & key );
+
+	void			Clear();
+	void			DeleteContents();
+
+	int				Num() const;
+	_value_ *		GetIndex( const int index ) const;
+	bool			GetIndexKey( const int index, _key_ & key ) const;
+
+	int				GetSpread() const;
+
+	idHashTableT &	operator=( const idHashTableT & other );
+
+protected:
+	void			Copy( const idHashTableT & other );
+
+private:
+	typedef idHashNodeT< _key_, _value_ > hashnode_t;
+
+	hashnode_t	**	heads;
+
+	int				tableSize;
+	int				numEntries;
+	int				tableSizeMask;
+};
+
+/*
+========================
+idHashTableT<_key_,_value_>::idHashTableT
+========================
+*/
+template< typename _key_, class _value_ >
+ID_INLINE idHashTableT<_key_,_value_>::idHashTableT( const int tableSize ) {
+	assert( idMath::IsPowerOfTwo( tableSize ) );
+
+	this->tableSize = tableSize;
+
+	heads = new (TAG_IDLIB_HASH) hashnode_t *[ tableSize ];
+	memset( heads, 0, sizeof( hashnode_t * ) * tableSize );
+
+	numEntries = 0;
+	tableSizeMask = tableSize - 1;
+}
+
+/*
+========================
+idHashTableT<_key_,_value_>::idHashTableT
+========================
+*/
+template< typename _key_, class _value_ >
+ID_INLINE idHashTableT<_key_,_value_>::idHashTableT( const idHashTableT & other ) {
+	Copy( other );
+}
+
+/*
+========================
+idHashTableT<_key_,_value_>::~idHashTableT
+========================
+*/
+template< typename _key_, class _value_ >
+ID_INLINE idHashTableT<_key_,_value_>::~idHashTableT() {
+	Clear();
+	delete [] heads;
+	heads = NULL;
+	tableSize = 0;
+	tableSizeMask = 0;
+	numEntries = 0;
+}
+
+/*
+========================
+idHashTableT<_key_,_value_>::Allocated
+========================
+*/
+template< typename _key_, class _value_ >
+ID_INLINE size_t idHashTableT<_key_,_value_>::Allocated() const {
+	return sizeof( heads ) * tableSize + sizeof( hashnode_t* ) * numEntries;
+}
+
+/*
+========================
+idHashTableT<_key_,_value_>::Size
+========================
+*/
+template< typename _key_, class _value_ >
+ID_INLINE size_t idHashTableT<_key_,_value_>::Size() const {
+	return sizeof( idHashTableT ) + sizeof( heads )* tableSize + sizeof( hashnode_t* ) * numEntries;
+}
+
+/*
+========================
+idHashTableT<_key_,_value_>::Set
+========================
+*/
+template< typename _key_, class _value_ >
+ID_INLINE _value_ & idHashTableT<_key_,_value_>::Set( const _key_ & key, const _value_ & value ) {
+	// insert sorted
+	int hash = hashnode_t::GetHash( key, tableSizeMask );
+	hashnode_t ** nextPtr = &(heads[ hash ] );
+	hashnode_t * node = * nextPtr;
+	for ( ; 
+		node != NULL;
+		nextPtr = &(node->next), node = *nextPtr ) {
+			int s = node->Compare( node->key, key );
+			if ( s == 0 ) {
+				// return existing hashed item
+				node->value = value;
+				return node->value;
+			}
+			if ( s > 0 ) {
+				break;
+			}
+	}
+
+	numEntries++;
+
+	*nextPtr = new (TAG_IDLIB_HASH) hashnode_t( key, value, heads[ hash ] );
+	(*nextPtr)->next = node;
+	return (*nextPtr)->value;
+}
+
+/*
+========================
+idHashTableT<_key_,_value_>::Get
+========================
+*/
+template< typename _key_, class _value_ >
+ID_INLINE bool idHashTableT<_key_,_value_>::Get( const _key_ & key, _value_ ** value ) {
+	int hash = hashnode_t::GetHash( key, tableSizeMask );
+	hashnode_t * node = heads[ hash ];
+	for ( ; node != NULL; node = node->next ) {
+		int s = node->Compare( node->key, key );
+		if ( s == 0 ) {
+			if ( value ) {
+				*value = &node->value;
+			}
+			return true;
+		}
+		if ( s > 0 ) {
+			break;
+		}
+	}
+	if ( value ) {
+		*value = NULL;
+	}
+	return false;
+}
+
+/*
+========================
+idHashTableT<_key_,_value_>::Get
+========================
+*/
+template< typename _key_, class _value_ >
+ID_INLINE bool idHashTableT<_key_,_value_>::Get( const _key_ & key, const _value_ ** value ) const {
+	int hash = hashnode_t::GetHash( key, tableSizeMask );
+	hashnode_t * node = heads[ hash ];
+	for ( ; node != NULL; node = node->next ) {
+		int s = node->Compare( node->key, key );
+		if ( s == 0 ) {
+			if ( value ) {
+				*value = &node->value;
+			}
+			return true;
+		}
+		if ( s > 0 ) {
+			break;
+		}
+	}
+	if ( value ) {
+		*value = NULL;
+	}
+	return false;
+}
+
+/*
+========================
+idHashTableT<_key_,_value_>::GetIndex
+========================
+*/
+template< typename _key_, class _value_ >
+ID_INLINE _value_ * idHashTableT<_key_,_value_>::GetIndex( const int index ) const {
+	if ( index < 0 || index > numEntries ) {
+		assert( 0 );
+		return NULL;
+	}
+
+	int count = 0;
+	for ( int i = 0; i < tableSize; i++ ) {
+		for ( hashnode_t * node = heads[ i ]; node != NULL; node = node->next ) {
+			if ( count == index ) {
+				return &node->value;
+			}
+			count++;
+		}
+	}
+	return NULL;
+}
+
+/*
+========================
+idHashTableT<_key_,_value_>::GetIndexKey
+========================
+*/
+template< typename _key_, class _value_ >
+ID_INLINE bool idHashTableT<_key_,_value_>::GetIndexKey( const int index, _key_ & key ) const {
+	if ( index < 0 || index > numEntries ) {
+		assert( 0 );
+		return false;
+	}
+
+	int count = 0;
+	for ( int i = 0; i < tableSize; i++ ) {
+		for ( hashnode_t * node = heads[ i ]; node != NULL; node = node->next ) {
+			if ( count == index ) {
+				key = node->key;
+				return true;
+			}
+			count++;
+		}
+	}
+	return false;
+}
+
+/*
+========================
+idHashTableT<_key_,_value_>::Remove
+========================
+*/
+template< typename _key_, class _value_ >
+ID_INLINE bool idHashTableT<_key_,_value_>::Remove( const _key_ & key ) {
+	int hash = hashnode_t::GetHash( key, tableSizeMask );
+	hashnode_t ** head = &heads[ hash ];
+	if ( *head ) {
+		hashnode_t * prev = NULL;
+		hashnode_t * node = *head;
+		for ( ; node != NULL; prev = node, node = node->next ) {
+			if ( node->key == key ) {
+				if ( prev ) {
+					prev->next = node->next;
+				} else {
+					*head = node->next;
+				}
+
+				delete node;
+				numEntries--;
+				return true;
+			}
+		}
+	}
+	return false;
+}
+
+/*
+========================
+idHashTableT<_key_,_value_>::Clear
+========================
+*/
+template< typename _key_, class _value_ >
+ID_INLINE void idHashTableT<_key_,_value_>::Clear() {
+	for ( int i = 0; i < tableSize; i++ ) {
+		hashnode_t * next = heads[ i ];
+		while ( next != NULL ) {
+			hashnode_t * node = next;
+			next = next->next;
+			delete node;
+		}
+		heads[ i ] = NULL;
+	}
+	numEntries = 0;
+}
+
+/*
+========================
+idHashTableT<_key_,_value_>::DeleteContents
+========================
+*/
+template< typename _key_, class _value_ >
+ID_INLINE void idHashTableT<_key_,_value_>::DeleteContents() {
+	for ( int i = 0; i < tableSize; i++ ) {
+		hashnode_t * next = heads[ i ];
+		while ( next != NULL ) {
+			hashnode_t * node = next;
+			next = next->next;
+			delete node->value;
+			delete node;
+		}
+		heads[ i ] = NULL;
+	}
+	numEntries = 0;
+}
+
+/*
+========================
+idHashTableT<_key_,_value_>::Num
+========================
+*/
+template< typename _key_, class _value_ >
+ID_INLINE int idHashTableT<_key_,_value_>::Num() const {
+	return numEntries;
+}
+
+/*
+========================
+idHashTableT<_key_,_value_>::GetSpread
+========================
+*/
+template< typename _key_, class _value_ >
+ID_INLINE int idHashTableT<_key_,_value_>::GetSpread() const {
+	if ( !numEntries ) {
+		return 100;
+	}
+
+	int average = numEntries / tableSize;
+	int error = 0;
+	for ( int i = 0; i < tableSize; i++ ) {
+		int numItems = 0;
+		for ( hashnode_t * node = heads[ i ]; node != NULL; node = node->next ) {
+			numItems++;
+		}
+		int e = abs( numItems - average );
+		if ( e > 1 ) {
+			error += e - 1;
+		}
+	}
+	return 100 - ( error * 100 / numEntries );
+}
+
+/*
+========================
+idHashTableT<_key_,_value_>::operator=
+========================
+*/
+template< typename _key_, class _value_ >
+ID_INLINE idHashTableT< _key_, _value_ > & idHashTableT<_key_,_value_>::operator=( const idHashTableT & other ) {
+	Copy( other );
+	return *this;
+}
+
+/*
+========================
+idHashTableT<_key_,_value_>::Copy
+========================
+*/
+template< typename _key_, class _value_ >
+ID_INLINE void idHashTableT<_key_,_value_>::Copy( const idHashTableT & other ) {
+	if ( &other == this ) {
+		return;
+	}
+	assert( other.tableSize > 0 );
+
+	tableSize		= other.tableSize;
+	heads			= new (TAG_IDLIB_HASH) hashnode_t *[ tableSize ];
+	numEntries		= other.numEntries;
+	tableSizeMask	= other.tableSizeMask;
+
+	for ( int i = 0; i < tableSize; i++ ) {
+		if ( !other.heads[ i ] ) {
+			heads[ i ] = NULL;
+			continue;
+		}
+		hashnode_t ** prev = & heads[ i ];
+		for ( hashnode_t * node = other.heads[ i ]; node != NULL; node = node->next ) {
+			*prev = new (TAG_IDLIB_HASH) hashnode_t( node->key, node->value, NULL );
+			prev = &( *prev )->next;
+		}
+	}
+}
+
+/*
+===============================================================================
+
+	General hash table. Slower than idHashIndex but it can also be used for
+	linked lists and other data structures than just indexes or arrays.
+
+===============================================================================
+*/
+
+template< class Type >
+class idHashTable {
+public:
+					idHashTable( int newtablesize = 256 );
+					idHashTable( const idHashTable<Type> &map );
+					~idHashTable();
+
+					// returns total size of allocated memory
+	size_t			Allocated() const;
+					// returns total size of allocated memory including size of hash table type
+	size_t			Size() const;
+
+	void			Set( const char *key, Type &value );
+	bool			Get( const char *key, Type **value = NULL ) const;
+	bool			Remove( const char *key );
+
+	void			Clear();
+	void			DeleteContents();
+
+					// the entire contents can be itterated over, but note that the
+					// exact index for a given element may change when new elements are added
+	int				Num() const;
+	Type *			GetIndex( int index ) const;
+
+	int				GetSpread() const;
+
+private:
+	struct hashnode_s {
+		idStr		key;
+		Type		value;
+		hashnode_s *next;
+
+		hashnode_s( const idStr &k, Type v, hashnode_s *n ) : key( k ), value( v ), next( n ) {};
+		hashnode_s( const char *k, Type v, hashnode_s *n ) : key( k ), value( v ), next( n ) {};
+	};
+
+	hashnode_s **	heads;
+
+	int				tablesize;
+	int				numentries;
+	int				tablesizemask;
+
+	int				GetHash( const char *key ) const;
+};
+
+/*
+================
+idHashTable<Type>::idHashTable
+================
+*/
+template< class Type >
+ID_INLINE idHashTable<Type>::idHashTable( int newtablesize ) {
+
+	assert( idMath::IsPowerOfTwo( newtablesize ) );
+
+	tablesize = newtablesize;
+	assert( tablesize > 0 );
+
+	heads = new (TAG_IDLIB_HASH) hashnode_s *[ tablesize ];
+	memset( heads, 0, sizeof( *heads ) * tablesize );
+
+	numentries		= 0;
+
+	tablesizemask = tablesize - 1;
+}
+
+/*
+================
+idHashTable<Type>::idHashTable
+================
+*/
+template< class Type >
+ID_INLINE idHashTable<Type>::idHashTable( const idHashTable<Type> &map ) {
+	int			i;
+	hashnode_s	*node;
+	hashnode_s	**prev;
+
+	assert( map.tablesize > 0 );
+
+	tablesize		= map.tablesize;
+	heads			= new (TAG_IDLIB_HASH) hashnode_s *[ tablesize ];
+	numentries		= map.numentries;
+	tablesizemask	= map.tablesizemask;
+
+	for( i = 0; i < tablesize; i++ ) {
+		if ( !map.heads[ i ] ) {
+			heads[ i ] = NULL;
+			continue;
+		}
+
+		prev = &heads[ i ];
+		for( node = map.heads[ i ]; node != NULL; node = node->next ) {
+			*prev = new (TAG_IDLIB_HASH) hashnode_s( node->key, node->value, NULL );
+			prev = &( *prev )->next;
+		}
+	}
+}
+
+/*
+================
+idHashTable<Type>::~idHashTable<Type>
+================
+*/
+template< class Type >
+ID_INLINE idHashTable<Type>::~idHashTable() {
+	Clear();
+	delete[] heads;
+}
+
+/*
+================
+idHashTable<Type>::Allocated
+================
+*/
+template< class Type >
+ID_INLINE size_t idHashTable<Type>::Allocated() const {
+	return sizeof( heads ) * tablesize + sizeof( *heads ) * numentries;
+}
+
+/*
+================
+idHashTable<Type>::Size
+================
+*/
+template< class Type >
+ID_INLINE size_t idHashTable<Type>::Size() const {
+	return sizeof( idHashTable<Type> ) + sizeof( heads ) * tablesize + sizeof( *heads ) * numentries;
+}
+
+/*
+================
+idHashTable<Type>::GetHash
+================
+*/
+template< class Type >
+ID_INLINE int idHashTable<Type>::GetHash( const char *key ) const {
+	return ( idStr::Hash( key ) & tablesizemask );
+}
+
+/*
+================
+idHashTable<Type>::Set
+================
+*/
+template< class Type >
+ID_INLINE void idHashTable<Type>::Set( const char *key, Type &value ) {
+	hashnode_s *node, **nextPtr;
+	int hash, s;
+
+	hash = GetHash( key );
+	for( nextPtr = &(heads[hash]), node = *nextPtr; node != NULL; nextPtr = &(node->next), node = *nextPtr ) {
+		s = node->key.Cmp( key );
+		if ( s == 0 ) {
+			node->value = value;
+			return;
+		}
+		if ( s > 0 ) {
+			break;
+		}
+	}
+
+	numentries++;
+
+	*nextPtr = new (TAG_IDLIB_HASH) hashnode_s( key, value, heads[ hash ] );
+	(*nextPtr)->next = node;
+}
+
+/*
+================
+idHashTable<Type>::Get
+================
+*/
+template< class Type >
+ID_INLINE bool idHashTable<Type>::Get( const char *key, Type **value ) const {
+	hashnode_s *node;
+	int hash, s;
+
+	hash = GetHash( key );
+	for( node = heads[ hash ]; node != NULL; node = node->next ) {
+		s = node->key.Cmp( key );
+		if ( s == 0 ) {
+			if ( value ) {
+				*value = &node->value;
+			}
+			return true;
+		}
+		if ( s > 0 ) {
+			break;
+		}
+	}
+
+	if ( value ) {
+		*value = NULL;
+	}
+
+	return false;
+}
+
+/*
+================
+idHashTable<Type>::GetIndex
+
+the entire contents can be itterated over, but note that the
+exact index for a given element may change when new elements are added
+================
+*/
+template< class Type >
+ID_INLINE Type *idHashTable<Type>::GetIndex( int index ) const {
+	hashnode_s	*node;
+	int			count;
+	int			i;
+
+	if ( ( index < 0 ) || ( index > numentries ) ) {
+		assert( 0 );
+		return NULL;
+	}
+
+	count = 0;
+	for( i = 0; i < tablesize; i++ ) {
+		for( node = heads[ i ]; node != NULL; node = node->next ) {
+			if ( count == index ) {
+				return &node->value;
+			}
+			count++;
+		}
+	}
+
+	return NULL;
+}
+
+/*
+================
+idHashTable<Type>::Remove
+================
+*/
+template< class Type >
+ID_INLINE bool idHashTable<Type>::Remove( const char *key ) {
+	hashnode_s	**head;
+	hashnode_s	*node;
+	hashnode_s	*prev;
+	int			hash;
+
+	hash = GetHash( key );
+	head = &heads[ hash ];
+	if ( *head ) {
+		for( prev = NULL, node = *head; node != NULL; prev = node, node = node->next ) {
+			if ( node->key == key ) {
+				if ( prev ) {
+					prev->next = node->next;
+				} else {
+					*head = node->next;
+				}
+
+				delete node;
+				numentries--;
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
+
+/*
+================
+idHashTable<Type>::Clear
+================
+*/
+template< class Type >
+ID_INLINE void idHashTable<Type>::Clear() {
+	int			i;
+	hashnode_s	*node;
+	hashnode_s	*next;
+
+	for( i = 0; i < tablesize; i++ ) {
+		next = heads[ i ];
+		while( next != NULL ) {
+			node = next;
+			next = next->next;
+			delete node;
+		}
+
+		heads[ i ] = NULL;
+	}
+
+	numentries = 0;
+}
+
+/*
+================
+idHashTable<Type>::DeleteContents
+================
+*/
+template< class Type >
+ID_INLINE void idHashTable<Type>::DeleteContents() {
+	int			i;
+	hashnode_s	*node;
+	hashnode_s	*next;
+
+	for( i = 0; i < tablesize; i++ ) {
+		next = heads[ i ];
+		while( next != NULL ) {
+			node = next;
+			next = next->next;
+			delete node->value;
+			delete node;
+		}
+
+		heads[ i ] = NULL;
+	}
+
+	numentries = 0;
+}
+
+/*
+================
+idHashTable<Type>::Num
+================
+*/
+template< class Type >
+ID_INLINE int idHashTable<Type>::Num() const {
+	return numentries;
+}
+
+#if defined(ID_TYPEINFO)
+#define __GNUC__ 99
+#endif
+
+#if !defined(__GNUC__) || __GNUC__ < 4
+/*
+================
+idHashTable<Type>::GetSpread
+================
+*/
+template< class Type >
+int idHashTable<Type>::GetSpread() const {
+	int i, average, error, e;
+	hashnode_s	*node;
+
+	// if no items in hash
+	if ( !numentries ) {
+		return 100;
+	}
+	average = numentries / tablesize;
+	error = 0;
+	for ( i = 0; i < tablesize; i++ ) {
+		numItems = 0;
+		for( node = heads[ i ]; node != NULL; node = node->next ) {
+			numItems++;
+		}
+		e = abs( numItems - average );
+		if ( e > 1 ) {
+			error += e - 1;
+		}
+	}
+	return 100 - (error * 100 / numentries);
+}
+#endif
+
+#if defined(ID_TYPEINFO)
+#undef __GNUC__
+#endif
+
+#endif /* !__HASHTABLE_H__ */