godot/core/hash_map.h
Rémi Verschelde d8223ffa75 Welcome in 2017, dear changelog reader!
That year should bring the long-awaited OpenGL ES 3.0 compatible renderer
with state-of-the-art rendering techniques tuned to work as low as middle
end handheld devices - without compromising with the possibilities given
for higher end desktop games of course. Great times ahead for the Godot
community and the gamers that will play our games!

(cherry picked from commit c7bc44d5ad)
2017-01-12 19:15:30 +01:00

630 lines
14 KiB
C++

/*************************************************************************/
/* hash_map.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#ifndef HASH_MAP_H
#define HASH_MAP_H
#include "hashfuncs.h"
#include "error_macros.h"
#include "ustring.h"
#include "os/memory.h"
#include "list.h"
class HashMapHahserDefault {
public:
static _FORCE_INLINE_ uint32_t hash(const String &p_string) { return p_string.hash(); }
static _FORCE_INLINE_ uint32_t hash(const char *p_cstr) { return hash_djb2(p_cstr); }
static _FORCE_INLINE_ uint32_t hash(const uint64_t p_int) {
uint64_t v=p_int;
v = (~v) + (v << 18); // v = (v << 18) - v - 1;
v = v ^ (v >> 31);
v = v * 21; // v = (v + (v << 2)) + (v << 4);
v = v ^ (v >> 11);
v = v + (v << 6);
v = v ^ (v >> 22);
return (int) v;
}
static _FORCE_INLINE_ uint32_t hash(const int64_t p_int) { return hash(uint64_t(p_int)); }
static _FORCE_INLINE_ uint32_t hash(const uint32_t p_int) { return p_int; }
static _FORCE_INLINE_ uint32_t hash(const int32_t p_int) { return (uint32_t)p_int; }
static _FORCE_INLINE_ uint32_t hash(const uint16_t p_int) { return p_int; }
static _FORCE_INLINE_ uint32_t hash(const int16_t p_int) { return (uint32_t)p_int; }
static _FORCE_INLINE_ uint32_t hash(const uint8_t p_int) { return p_int; }
static _FORCE_INLINE_ uint32_t hash(const int8_t p_int) { return (uint32_t)p_int; }
static _FORCE_INLINE_ uint32_t hash(const wchar_t p_wchar) { return (uint32_t)p_wchar; }
// static _FORCE_INLINE_ uint32_t hash(const void* p_ptr) { return uint32_t(uint64_t(p_ptr))*(0x9e3779b1L); }
};
/**
* @class HashMap
* @author Juan Linietsky <reduzio@gmail.com>
*
* Implementation of a standard Hashing HashMap, for quick lookups of Data associated with a Key.
* The implementation provides hashers for the default types, if you need a special kind of hasher, provide
* your own.
* @param TKey Key, search is based on it, needs to be hasheable. It is unique in this container.
* @param TData Data, data associated with the key
* @param Hasher Hasher object, needs to provide a valid static hash function for TKey
* @param MIN_HASH_TABLE_POWER Miminum size of the hash table, as a power of two. You rarely need to change this parameter.
* @param RELATIONSHIP Relationship at which the hash table is resized. if amount of elements is RELATIONSHIP
* times bigger than the hash table, table is resized to solve this condition. if RELATIONSHIP is zero, table is always MIN_HASH_TABLE_POWER.
*
*/
template<class TKey, class TData, class Hasher=HashMapHahserDefault,uint8_t MIN_HASH_TABLE_POWER=3,uint8_t RELATIONSHIP=8>
class HashMap {
public:
struct Pair {
TKey key;
TData data;
Pair() {}
Pair(const TKey& p_key, const TData& p_data) { key=p_key; data=p_data; }
};
private:
struct Entry {
uint32_t hash;
Entry *next;
Pair pair;
Entry() { next=0; }
};
Entry **hash_table;
uint8_t hash_table_power;
uint32_t elements;
void make_hash_table() {
ERR_FAIL_COND( hash_table );
hash_table = memnew_arr( Entry*, (1<<MIN_HASH_TABLE_POWER) );
hash_table_power = MIN_HASH_TABLE_POWER;
elements=0;
for (int i=0;i<(1<<MIN_HASH_TABLE_POWER);i++)
hash_table[i]=0;
}
void erase_hash_table() {
ERR_FAIL_COND(elements);
memdelete_arr( hash_table );
hash_table=0;
hash_table_power=0;
elements=0;
}
void check_hash_table() {
int new_hash_table_power=-1;
if ((int)elements > ( (1<<hash_table_power) * RELATIONSHIP ) ) {
/* rehash up */
new_hash_table_power=hash_table_power+1;
while( (int)elements > ( (1<<new_hash_table_power) * RELATIONSHIP ) ) {
new_hash_table_power++;
}
} else if ( (hash_table_power>(int)MIN_HASH_TABLE_POWER) && ((int)elements < ( (1<<(hash_table_power-1)) * RELATIONSHIP ) ) ) {
/* rehash down */
new_hash_table_power=hash_table_power-1;
while( (int)elements < ( (1<<(new_hash_table_power-1)) * RELATIONSHIP ) ) {
new_hash_table_power--;
}
if (new_hash_table_power<(int)MIN_HASH_TABLE_POWER)
new_hash_table_power=MIN_HASH_TABLE_POWER;
}
if (new_hash_table_power==-1)
return;
Entry ** new_hash_table = memnew_arr( Entry*, (1<<new_hash_table_power) );
if (!new_hash_table) {
ERR_PRINT("Out of Memory");
return;
}
for (int i=0;i<(1<<new_hash_table_power);i++) {
new_hash_table[i]=0;
}
for (int i=0;i<(1<<hash_table_power);i++) {
while( hash_table[i] ) {
Entry *se=hash_table[i];
hash_table[i]=se->next;
int new_pos = se->hash & ((1<<new_hash_table_power)-1);
se->next=new_hash_table[new_pos];
new_hash_table[new_pos]=se;
}
}
if (hash_table)
memdelete_arr( hash_table );
hash_table=new_hash_table;
hash_table_power=new_hash_table_power;
}
/* I want to have only one function.. */
_FORCE_INLINE_ const Entry * get_entry( const TKey& p_key ) const {
uint32_t hash = Hasher::hash( p_key );
uint32_t index = hash&((1<<hash_table_power)-1);
Entry *e = hash_table[index];
while (e) {
/* checking hash first avoids comparing key, which may take longer */
if (e->hash == hash && e->pair.key == p_key ) {
/* the pair exists in this hashtable, so just update data */
return e;
}
e=e->next;
}
return NULL;
}
Entry * create_entry(const TKey& p_key) {
/* if entry doesn't exist, create it */
Entry *e = memnew( Entry );
ERR_FAIL_COND_V(!e,NULL); /* out of memory */
uint32_t hash = Hasher::hash( p_key );
uint32_t index = hash&((1<<hash_table_power)-1);
e->next = hash_table[index];
e->hash = hash;
e->pair.key=p_key;
hash_table[index]=e;
elements++;
return e;
}
void copy_from(const HashMap& p_t) {
if (&p_t==this)
return; /* much less bother with that */
clear();
if (!p_t.hash_table || p_t.hash_table_power==0)
return; /* not copying from empty table */
hash_table = memnew_arr(Entry*,1<<p_t.hash_table_power);
hash_table_power=p_t.hash_table_power;
elements=p_t.elements;
for (int i=0;i<( 1<<p_t.hash_table_power );i++) {
hash_table[i]=NULL;
/* elements will be in the reverse order, but it doesn't matter */
const Entry *e = p_t.hash_table[i];
while(e) {
Entry *le = memnew( Entry ); /* local entry */
*le=*e; /* copy data */
/* add to list and reassign pointers */
le->next=hash_table[i];
hash_table[i]=le;
e=e->next;
}
}
}
public:
void set( const TKey& p_key, const TData& p_data ) {
set( Pair( p_key, p_data ) );
}
void set( const Pair& p_pair ) {
Entry *e=NULL;
if (!hash_table)
make_hash_table(); // if no table, make one
else
e = const_cast<Entry*>( get_entry(p_pair.key) );
/* if we made it up to here, the pair doesn't exist, create and assign */
if (!e) {
e=create_entry(p_pair.key);
if (!e)
return;
check_hash_table(); // perform mantenience routine
}
e->pair.data = p_pair.data;
}
bool has( const TKey& p_key ) const {
return getptr(p_key)!=NULL;
}
/**
* Get a key from data, return a const reference.
* WARNING: this doesn't check errors, use either getptr and check NULL, or check
* first with has(key)
*/
const TData& get( const TKey& p_key ) const {
const TData* res = getptr(p_key);
ERR_FAIL_COND_V(!res,*res);
return *res;
}
TData& get( const TKey& p_key ) {
TData* res = getptr(p_key);
ERR_FAIL_COND_V(!res,*res);
return *res;
}
/**
* Same as get, except it can return NULL when item was not found.
* This is mainly used for speed purposes.
*/
_FORCE_INLINE_ TData* getptr( const TKey& p_key ) {
if (!hash_table)
return NULL;
Entry *e=const_cast<Entry*>(get_entry(p_key ));
if (e)
return &e->pair.data;
return NULL;
}
_FORCE_INLINE_ const TData* getptr( const TKey& p_key ) const {
if (!hash_table)
return NULL;
const Entry *e=const_cast<Entry*>(get_entry(p_key ));
if (e)
return &e->pair.data;
return NULL;
}
/**
* Same as get, except it can return NULL when item was not found.
* This version is custom, will take a hash and a custom key (that should support operator==()
*/
template<class C>
_FORCE_INLINE_ TData* custom_getptr( C p_custom_key,uint32_t p_custom_hash ) {
if (!hash_table)
return NULL;
uint32_t hash = p_custom_hash;
uint32_t index = hash&((1<<hash_table_power)-1);
Entry *e = hash_table[index];
while (e) {
/* checking hash first avoids comparing key, which may take longer */
if (e->hash == hash && e->pair.key == p_custom_key ) {
/* the pair exists in this hashtable, so just update data */
return &e->pair.data;
}
e=e->next;
}
return NULL;
}
template<class C>
_FORCE_INLINE_ const TData* custom_getptr( C p_custom_key,uint32_t p_custom_hash ) const {
if (!hash_table)
return NULL;
uint32_t hash = p_custom_hash;
uint32_t index = hash&((1<<hash_table_power)-1);
const Entry *e = hash_table[index];
while (e) {
/* checking hash first avoids comparing key, which may take longer */
if (e->hash == hash && e->pair.key == p_custom_key ) {
/* the pair exists in this hashtable, so just update data */
return &e->pair.data;
}
e=e->next;
}
return NULL;
}
/**
* Erase an item, return true if erasing was succesful
*/
bool erase( const TKey& p_key ) {
if (!hash_table)
return false;
uint32_t hash = Hasher::hash( p_key );
uint32_t index = hash&((1<<hash_table_power)-1);
Entry *e = hash_table[index];
Entry *p=NULL;
while (e) {
/* checking hash first avoids comparing key, which may take longer */
if (e->hash == hash && e->pair.key == p_key ) {
if (p) {
p->next=e->next;
} else {
//begin of list
hash_table[index]=e->next;
}
memdelete(e);
elements--;
if (elements==0)
erase_hash_table();
else
check_hash_table();
return true;
}
p=e;
e=e->next;
}
return false;
}
inline const TData& operator[](const TKey& p_key) const { //constref
return get(p_key);
}
inline TData& operator[](const TKey& p_key ) { //assignment
Entry *e=NULL;
if (!hash_table)
make_hash_table(); // if no table, make one
else
e = const_cast<Entry*>( get_entry(p_key) );
/* if we made it up to here, the pair doesn't exist, create */
if (!e) {
e=create_entry(p_key);
if (!e)
return *(TData*)NULL; /* panic! */
check_hash_table(); // perform mantenience routine
}
return e->pair.data;
}
/**
* Get the next key to p_key, and the first key if p_key is null.
* Returns a pointer to the next key if found, NULL otherwise.
* Adding/Removing elements while iterating will, of course, have unexpected results, don't do it.
*
* Example:
*
* const TKey *k=NULL;
*
* while( (k=table.next(k)) ) {
*
* print( *k );
* }
*
*/
const TKey* next(const TKey* p_key) const {
if (!hash_table) return NULL;
if (!p_key) { /* get the first key */
for (int i=0;i<(1<<hash_table_power);i++) {
if (hash_table[i]) {
return &hash_table[i]->pair.key;
}
}
} else { /* get the next key */
const Entry *e = get_entry( *p_key );
ERR_FAIL_COND_V( !e, NULL ); /* invalid key supplied */
if (e->next) {
/* if there is a "next" in the list, return that */
return &e->next->pair.key;
} else {
/* go to next entries */
uint32_t index = e->hash&((1<<hash_table_power)-1);
index++;
for (int i=index;i<(1<<hash_table_power);i++) {
if (hash_table[i]) {
return &hash_table[i]->pair.key;
}
}
}
/* nothing found, was at end */
}
return NULL; /* nothing found */
}
inline unsigned int size() const {
return elements;
}
inline bool empty() const {
return elements==0;
}
void clear() {
/* clean up */
if (hash_table) {
for (int i=0;i<(1<<hash_table_power);i++) {
while (hash_table[i]) {
Entry *e=hash_table[i];
hash_table[i]=e->next;
memdelete( e );
}
}
memdelete_arr( hash_table );
}
hash_table=0;
hash_table_power=0;
elements=0;
}
void operator=(const HashMap& p_table) {
copy_from(p_table);
}
HashMap() {
hash_table=NULL;
elements=0;
hash_table_power=0;
}
void get_key_list(List<TKey> *p_keys) const {
if (!hash_table)
return;
for(int i=0;i<(1<<hash_table_power);i++) {
Entry *e=hash_table[i];
while(e) {
p_keys->push_back(e->pair.key);
e=e->next;
}
}
}
HashMap(const HashMap& p_table) {
hash_table=NULL;
elements=0;
hash_table_power=0;
copy_from(p_table);
}
~HashMap() {
clear();
}
};
#endif