| Bullet Collision Detection & Physics Library
    | 
 
 
 
Go to the documentation of this file.
   42                 static const unsigned int InitialFNV = 2166136261u;
 
   43                 static const unsigned int FNVMultiple = 16777619u;
 
   46                 unsigned int hash = InitialFNV;
 
   48                 for (
int i = 0; 
m_string1.c_str()[i]; i++)
 
   51                         hash = hash * FNVMultiple;            
 
   94                 unsigned int key = 
m_uid;
 
  133                 const bool VOID_IS_8 = ((
sizeof(
void*) == 8));
 
  147 template <
class Value>
 
  170                 unsigned int key = 
m_uid;
 
  182 template <
class Value>
 
  204                 unsigned int key = 
m_uid;
 
  218 template <
class Key, 
class Value>
 
  242                         for (i = 0; i < newCapacity; ++i)
 
  246                         for (i = 0; i < newCapacity; ++i)
 
  251                         for (i = 0; i < curHashtableSize; i++)
 
  264         void insert(
const Key& key, 
const Value& value)
 
  282                 if (oldCapacity < newCapacity)
 
  308                 while (index != pairIndex)
 
  331                 if (lastPairIndex == pairIndex)
 
  345                 while (index != lastPairIndex)
 
  424         const Value* 
find(
const Key& key)
 const 
  470 #endif  //BT_HASH_MAP_H 
  
unsigned int getHash() const
unsigned int getHash() const
btAlignedObjectArray< int > m_hashTable
const void * getPointer() const
const Value * getAtIndex(int index) const
void clear()
clear the array, deallocated memory. Generally it is better to use array.resize(0),...
very basic hashable string implementation, compatible with btHashMap
void remove(const Key &key)
bool equals(const btHashPtr &other) const
btAlignedObjectArray< Value > m_valueArray
unsigned int getHash() const
The btHashMap template class implements a generic and lightweight hashmap.
Value * find(const Key &key)
int findIndex(const Key &key) const
void resize(int newsize, const T &fillData=T())
unsigned int m_hashValues[2]
btAlignedObjectArray< Key > m_keyArray
btHashString(const char *name)
bool equals(const btHashInt &other) const
bool equals(const btHashString &other) const
unsigned int getHash() const
Value * getAtIndex(int index)
void growTables(const Key &)
unsigned int getHash() const
const Value * find(const Key &key) const
#define SIMD_FORCE_INLINE
const Key getKeyAtIndex(int index) const
bool equals(const btHashKeyPtr< Value > &other) const
Key getKeyAtIndex(int index)
btHashPtr(const void *ptr)
int capacity() const
return the pre-allocated (reserved) elements, this is at least as large as the total number of elemen...
void insert(const Key &key, const Value &value)
Value * operator[](const Key &key)
bool equals(const btHashKey< Value > &other) const
const Value * operator[](const Key &key) const
btAlignedObjectArray< int > m_next
void push_back(const T &_Val)
int size() const
return the number of elements in the array