hashtable_api.h

Go to the documentation of this file.

 
#ifndef HASHTABLE_API_H
#define HASHTABLE_API_H
 
#include <stdint.h>
 
 
#define HASHTABLE_LIB_VERSION "v0.1.1"
 
 
#if !defined(HASHTABLE_SIZE_T_UINT16) && !defined(HASHTABLE_SIZE_T_UINT32) && !defined(HASHTABLE_SIZE_T_SYS)
#define HASHTABLE_SIZE_T_SYS
#endif // if !defined..
 
 
#if defined(HASHTABLE_SIZE_T_UINT16)
typedef uint16_t hashtable_size_t;
#elif defined(HASHTABLE_SIZE_T_UINT32)
typedef uint32_t hashtable_size_t;
#elif defined(HASHTABLE_SIZE_T_SYS)
typedef size_t hashtable_size_t;
#else
#error("HASHTABLE_SIZE_T option not defined")
#endif // if defined....
 
 
#define HASHTABLE_MIN_ARRAY_COUNT (10u)
 
 
#define HASHTABLE_MIN_BUFFER_SIZE(array_count)                                 \
    (sizeof(_keyval_pair_table_data_t) + sizeof(_keyval_pair_list_table_t) +   \
    ((array_count) * sizeof(_keyval_pair_list_t)) +                            \
    sizeof(_keyval_pair_data_block_t))
 
 
typedef uint32_t (*hashtable_hashfunc_t)(const char *data, const hashtable_size_t size);
 
 
typedef struct
{
    hashtable_hashfunc_t hash;    
    uint32_t array_count;         
} hashtable_config_t;
 
 
typedef struct
{
    hashtable_config_t config;    
    uint32_t entry_count;         
    size_t data_size;             
    void *table_data;             
} hashtable_t;
 
 
int hashtable_create(hashtable_t *table, const hashtable_config_t *config,
                     void *buffer, size_t buffer_size);
 
 
int hashtable_insert(hashtable_t *table, const char *key, const hashtable_size_t key_size,
                     const char *value, const hashtable_size_t value_size);
 
 
int hashtable_remove(hashtable_t *table, const char *key, const hashtable_size_t key_size);
 
 
int hashtable_retrieve(hashtable_t *table, const char *key, const hashtable_size_t key_size,
                       char **value, hashtable_size_t *value_size);
 
 
int hashtable_has_key(hashtable_t *table, const char *key, const hashtable_size_t key_size);
 
 
int hashtable_bytes_remaining(hashtable_t *table, size_t *bytes_remaining);
 
 
int hashtable_next_item(hashtable_t *table, char **key, hashtable_size_t *key_size,
                        char **value, hashtable_size_t *value_size);
 
 
int hashtable_reset_cursor(hashtable_t *table);
 
 
int hashtable_clear(hashtable_t *table);
 
 
int hashtable_default_config(hashtable_config_t *config, size_t buffer_size);
 
 
char *hashtable_error_message(void);
 
 
#ifdef HASHTABLE_PACKED_STRUCT
#define _HASHTABLE_PACKED __attribute__((packed))
#else
#define _HASHTABLE_PACKED
#endif // HASHTABLE_PACKED_STRUCT
 
 
typedef struct _keyval_pair
{
    struct _keyval_pair *next;    
    hashtable_size_t key_size;    
    hashtable_size_t value_size;  
    uint8_t data[];               
} _HASHTABLE_PACKED _keyval_pair_t;
 
 
typedef struct
{
    _keyval_pair_t *head;  
    _keyval_pair_t *tail;  
} _keyval_pair_list_t;
 
 
typedef struct
{
    _keyval_pair_list_t freelist;  
    size_t total_bytes;            
    size_t bytes_used;             
    uint8_t data[];                
} _keyval_pair_data_block_t;
 
 
typedef struct
{
    uint32_t array_count;          
    _keyval_pair_list_t table[];   
} _keyval_pair_list_table_t;
 
 
typedef struct
{
    _keyval_pair_list_table_t *list_table;  
    _keyval_pair_data_block_t *data_block;  
    uint32_t cursor_array_index;            
    uint32_t cursor_items_traversed;        
    _keyval_pair_t *cursor_item;            
    uint8_t cursor_limit;                   
} _keyval_pair_table_data_t;
 
#endif // HASHTABLE_API_H