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;
  for(size_t i = 1; i < sizeof(size_t) * CHAR_BIT; i *= 2)
    x |= x >> i;
  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 */