xroad_hashmap.h

Go to the documentation of this file.

 
#pragma once
 
#include "xroad_common_fwd.h"
#include "xroad_common_types.h"
#include "xroad_aux.h"
#include <stdlib.h>
#include <stddef.h>
#include <stdalign.h>
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#define XROAD_HASHMAP_ENTRY_STRUCT(key_type, value_type) struct { int8_t info; key_type key; value_type value; int8_t last_member; }
#define XROAD_HASHMAP_ENTRY_KEY_OFFSET(key_type, value_type) offsetof(XROAD_HASHMAP_ENTRY_STRUCT(key_type, value_type), key)
#define XROAD_HASHMAP_ENTRY_VALUE_OFFSET(key_type, value_type) offsetof(XROAD_HASHMAP_ENTRY_STRUCT(key_type, value_type), value)
#define XROAD_HASHMAP_ENTRY_SIZE(key_type, value_type) offsetof(XROAD_HASHMAP_ENTRY_STRUCT(key_type, value_type), last_member)
 
typedef uint32_t (*xroad_hashmap_hash_func_t)(const void*, uint32_t);
 
typedef int32_t (*xroad_hashmap_equal_func_t)(const void*, const void*, uint32_t);
 
typedef void (*xroad_hashmap_free_func_t)(void*);
 
uint32_t xroad_hashmap_hash_func_cstr(const void*, uint32_t);
int32_t xroad_hashmap_equal_func_cstr(const void*, const void*, uint32_t);
void xroad_hashmap_free_func_cstr(void*);
 
uint32_t xroad_hashmap_hash_func_xroad_str(const void*, uint32_t);
int32_t xroad_hashmap_equal_func_xroad_str(const void*, const void*, uint32_t);
void xroad_hashmap_free_func_xroad_str(void*);
 
typedef struct
{
   uint32_t                   initial_size;
   xroad_hashmap_hash_func_t  hash;
   xroad_hashmap_equal_func_t equal;
   xroad_hashmap_free_func_t  key_dtor;
   xroad_hashmap_free_func_t  value_dtor;
   xroad_mem_pool_t*          pool;
} xroad_hashmap_va_args_t;
 
typedef struct
{
   xroad_hashmap_entry_t* entry;    
   xroad_errno_t          result;   
} xroad_hashmap_insert_result_t;
 
xroad_hashmap_t* xroad_hashmap_create_ex(uint32_t sizeof_key,
                                         uint32_t sizeof_value,
                                         uint32_t sizeof_entry,
                                         uint32_t key_offset,
                                         uint32_t value_offset,
                                         uint32_t initiad_size,
                                         xroad_hashmap_hash_func_t  hash_func,
                                         xroad_hashmap_equal_func_t equal_func,
                                         xroad_hashmap_free_func_t  key_free_func,
                                         xroad_hashmap_free_func_t  value_free_func,
                                         xroad_mem_pool_t* pool);
 
#define xroad_hashmap_create(key_type, value_type, ...)                            \
({                                                                                 \
   xroad_hashmap_va_args_t args = {__VA_ARGS__};                                   \
   xroad_hashmap_create_ex(sizeof(key_type), sizeof(value_type),                   \
                           XROAD_HASHMAP_ENTRY_SIZE(key_type, value_type),         \
                           XROAD_HASHMAP_ENTRY_KEY_OFFSET(key_type, value_type),   \
                           XROAD_HASHMAP_ENTRY_VALUE_OFFSET(key_type, value_type), \
                           args.initial_size, args.hash, args.equal,               \
                           args.key_dtor, args.value_dtor, args.pool);             \
})
 
void xroad_hashmap_destroy(xroad_hashmap_t* hashmap);
 
#define __xroad_hashmap_dtor__ __dtor__(xroad_hashmap_destructor)
void xroad_hashmap_destructor(void* hashmap_ptr);
 
void xroad_hashmap_reserve(xroad_hashmap_t* hashmap, uint32_t size);
 
xroad_hashmap_insert_result_t xroad_hashmap_insert(xroad_hashmap_t* hashmap, const void* key, const void* value);
 
xroad_hashmap_entry_t* xroad_hashmap_find(xroad_hashmap_t* hashmap, const void* key);
 
void xroad_hashmap_clear(xroad_hashmap_t* hashmap);
 
uint32_t xroad_hashmap_get_key_size(const xroad_hashmap_t* hashmap);
 
uint32_t xroad_hashmap_get_value_size(const xroad_hashmap_t* hashmap);
 
xroad_errno_t xroad_hashmap_delete(xroad_hashmap_t* hashmap, const void* key, bool free_resources);
 
uint32_t xroad_hashmap_get_size(xroad_hashmap_t* hashmap);
 
xroad_list_t* xroad_hashmap_keys_to_list(xroad_hashmap_t* hashmap);
 
xroad_list_t* xroad_hashmap_values_to_list(xroad_hashmap_t* hashmap);
 
void* xroad_hashmap_entry_get_key(xroad_hashmap_t* hashmap, xroad_hashmap_entry_t* entry);
 
void* xroad_hashmap_entry_get_value(xroad_hashmap_t* hashmap, xroad_hashmap_entry_t* entry);
 
void xroad_hashmap_entry_set_value(xroad_hashmap_t* hashmap, xroad_hashmap_entry_t* entry, const void* value, bool free_resources);
 
void xroad_hashmap_entry_delete(xroad_hashmap_t* hashmap, xroad_hashmap_entry_t* entry, bool free_resources);
 
xroad_hashmap_entry_t* xroad_hashmap_entry_delete_and_get_next(xroad_hashmap_t* hashmap, xroad_hashmap_entry_t* entry, bool free_resources);
 
xroad_hashmap_entry_t* xroad_hashmap_get_first(xroad_hashmap_t* hashmap);
 
xroad_hashmap_entry_t* xroad_hashmap_entry_get_next(xroad_hashmap_t* hashmap, xroad_hashmap_entry_t* entry);
 
#ifdef __cplusplus
}
#endif