hashtable.h

Go to the documentation of this file.

#ifndef CMR_HASHTABLE_INTERNAL_H
#define CMR_HASHTABLE_INTERNAL_H
 
#include "env_internal.h"
 
#include <limits.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
static inline
size_t nextPower2(size_t x)
{
  x |= x >> 1;
  x |= x >> 2;
  x |= x >> 4;
  x |= x >> 8;
  x |= x >> 16;
  x |= x >> 32;
  return x + 1;
}
 
typedef struct _CMR_LINEARHASHTABLE_ARRAY CMR_LINEARHASHTABLE_ARRAY;
typedef size_t CMR_LINEARHASHTABLE_BUCKET;
typedef size_t CMR_LINEARHASHTABLE_HASH;
 
CMR_ERROR CMRlinearhashtableArrayCreate(
  CMR* cmr,                     
  CMR_LINEARHASHTABLE_ARRAY** phashtable,  
  size_t initialSize,         
  size_t initialKeyMemory     
);
 
CMR_ERROR CMRlinearhashtableArrayFree(
  CMR* cmr,                   
  CMR_LINEARHASHTABLE_ARRAY** phashtable 
);
 
bool CMRlinearhashtableArrayFind(
  CMR_LINEARHASHTABLE_ARRAY* hashtable,  
  const void* keyArray,               
  size_t keyLength,                   
  CMR_LINEARHASHTABLE_BUCKET* pbucket,   
  CMR_LINEARHASHTABLE_HASH* phash        
);
 
const void* CMRlinearhashtableArrayKey(
  CMR_LINEARHASHTABLE_ARRAY* hashtable,  
  CMR_LINEARHASHTABLE_BUCKET bucket,     
  size_t* pKeyLength                  
);
 
const void* CMRlinearhashtableArrayValue(
  CMR_LINEARHASHTABLE_ARRAY* hashtable,  
  CMR_LINEARHASHTABLE_BUCKET bucket      
);
 
CMR_ERROR CMRlinearhashtableArrayInsertBucketHash(
  CMR* cmr,                             
  CMR_LINEARHASHTABLE_ARRAY* hashtable,  
  const void* keyArray,               
  size_t keyLength,                   
  CMR_LINEARHASHTABLE_BUCKET bucket,     
  CMR_LINEARHASHTABLE_HASH hash,         
  const void* value                   
);
 
CMR_ERROR CMRlinearhashtableArrayInsert(
  CMR* cmr,                   
  CMR_LINEARHASHTABLE_ARRAY* hashtable,  
  const void* keyArray,     
  size_t keyLength,         
  const void* value         
);
 
 
 
typedef struct _CMR_LISTHASHTABLE CMR_LISTHASHTABLE;
typedef size_t CMR_LISTHASHTABLE_VALUE;
typedef size_t CMR_LISTHASHTABLE_HASH;
typedef size_t CMR_LISTHASHTABLE_BUCKET;
typedef size_t CMR_LISTHASHTABLE_ENTRY;
 
CMR_ERROR CMRlisthashtableCreate(
  CMR* cmr,                         
  CMR_LISTHASHTABLE** phashtable,  
  size_t initialNumBuckets,       
  size_t initialMemNodes          
);
 
CMR_ERROR CMRlisthashtableFree(
  CMR* cmr,                       
  CMR_LISTHASHTABLE** phashtable 
);
 
CMR_LISTHASHTABLE_ENTRY CMRlisthashtableFindFirst(
  CMR_LISTHASHTABLE* hashtable,  
  CMR_LISTHASHTABLE_HASH hash    
);
 
CMR_LISTHASHTABLE_ENTRY CMRlisthashtableFindNext(
  CMR_LISTHASHTABLE* hashtable,  
  CMR_LISTHASHTABLE_HASH hash,   
  CMR_LISTHASHTABLE_ENTRY entry  
);
 
CMR_LISTHASHTABLE_VALUE CMRlisthashtableValue(
  CMR_LISTHASHTABLE* hashtable,  
  CMR_LISTHASHTABLE_ENTRY entry  
);
 
CMR_LISTHASHTABLE_HASH CMRlisthashtableHash(
  CMR_LISTHASHTABLE* hashtable,  
  CMR_LISTHASHTABLE_ENTRY entry  
);
 
size_t CMRlisthashtableNumBuckets(
  CMR_LISTHASHTABLE* hashtable 
);
 
CMR_ERROR CMRlisthashtableInsert(
  CMR* cmr,                       
  CMR_LISTHASHTABLE* hashtable,   
  CMR_LISTHASHTABLE_HASH hash,    
  CMR_LISTHASHTABLE_VALUE value,  
  CMR_LISTHASHTABLE_ENTRY* pentry 
);
 
CMR_ERROR CMRlisthashtableRemove(
  CMR* cmr,                     
  CMR_LISTHASHTABLE* hashtable, 
  CMR_LISTHASHTABLE_ENTRY entry 
);
 
#define RANGE_SIGNED_HASH (LLONG_MAX/2)
 
static inline
long long projectSignedHash(long long value)
{
  return ((value + RANGE_SIGNED_HASH - 1) % (2*RANGE_SIGNED_HASH-1)) - (RANGE_SIGNED_HASH-1);
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* CMR_HASHTABLE_INTERNAL_H */