gullradriel/nilorea-library
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
Page: Module HASH_TABLE
Pages
Examples Files Home Module AABB3D Module ACCEPT_POOL Module ALLEGRO4 Module ALLEGRO5 Module ANIM_LIB Module ASTAR Module ATLAS_LIB Module AVRO Module CLOCK_SYNC Module COMMONS Module CONFIGFILE Module CYPHER_BASE64 Module CYPHER_VIGENERE Module DEAD_RECKONING Module ENUMS Module EXCEPTIONS Module GAME_ENV Module GIT Module GUI Module HASH_TABLE Module ISOMETRIC_ENGINE Module LIST Module LOG Module LOGNODUP Module LZ4 Module NETWORKING Module NETWORK_MSG Module N_COOKIES Module N_DIFF Module N_DIGEST Module N_DISK_CACHE Module N_DNS Module N_ECC Module N_ENTROPY Module N_FILES Module N_FLUIDS Module N_GUI_COLOR Module N_GUI_COLORWHEEL Module N_GUI_CURVE Module N_GUI_GRID Module N_GUI_POPUP Module N_HEX Module N_HTTP3 Module N_HTTP_COOKIE Module N_HTTP_FORM Module N_HTTP_MIME Module N_HTTP_REQ Module N_HTTP_RESP Module N_HTTP_ROUTER Module N_HTTP_SERVER Module N_ICC Module N_JSON Module N_KAFKA Module N_LINALG Module N_MODULE Module N_OPENSSL_COMPAT Module N_PRETTY Module N_PTH Module N_QUERY Module N_RANDOM Module N_SHA256 Module N_STR Module N_TIFF Module N_TIME Module N_USER Module N_X509 Module N_ZIP Module PARTICLES Module PCRE Module PHYSICS Module SIGNALS Module STACK Module THREADS Module TRAJECTORY Module TREE Module ZLIB Modules Pages Struct A4_BMP Struct A4_TIMER Struct AABB3D Struct ANIM_DATA Struct ANIM_FRAME Struct ANIM_GFX Struct ANIM_LIB Struct ASTAR_BOX Struct ASTAR_CELL Struct ASTAR_GRID Struct ASTAR_HEAP Struct ASTAR_HEAP_NODE Struct ASTAR_NODE Struct ASTAR_PATH Struct AVRO_FIELD Struct AVRO_READER Struct AVRO_SCHEMA Struct BITMAP Struct CALLBACK_DATA Struct CA_CTX Struct CLIENT_JOB Struct CLIENT_STATE Struct CONFIG_FILE Struct CONFIG_FILE_SECTION Struct CYPHER_PARAM Struct DATA Struct DEMO_PANEL Struct DICTIONARY_DEFINITION Struct DICTIONARY_ENTRY Struct DIFF_OUT Struct DIFF_TEXT Struct DRAW_STATE Struct DR_ENTITY Struct DR_STATE Struct DR_VEC3 Struct ExceptionContextList Struct FONT Struct GAME_ENV Struct H2BUF Struct H2_DYN_ENTRY Struct H2_STREAM Struct HASH_NODE Struct HASH_TABLE Struct ISO_DRAW_ENTRY Struct ISO_MAP Struct ISO_PROJECTION Struct ISO_TILE_SEGMENT Struct ISO_TILE_SEGMENTS Struct ISO_VISIBLE_EDGES Struct JS_STATE Struct LEX_ITEM Struct LIST Struct LIST_NODE Struct LOG_LEVELS Struct LexMenu Struct MEMBER Struct MIDI Struct NESTED Struct NETWORK Struct NETWORK_HTTP_INFO Struct NETWORK_POOL Struct NETWORK_SSL_THREAD_PARAMS Struct NETW_ACCEPT_POOL Struct NETW_ACCEPT_POOL_STATS Struct NETW_MSG Struct NETW_SNI_ARG Struct NODE_DATA Struct N_ATLAS Struct N_ATLAS_PAGE Struct N_CLOCK_SYNC Struct N_COOKIE Struct N_COOKIE_JAR Struct N_DIFF_LINE Struct N_DIFF_RESULT Struct N_DISK_CACHE Struct N_ENTROPY_BIT Struct N_ENTROPY_POS Struct N_FILE_INFO Struct N_FLUID Struct N_FLUID_THREAD_PARAMS Struct N_FORM_FIELD Struct N_GIT_COMMIT_INFO Struct N_GIT_REMOTE_AUTH Struct N_GIT_REPO Struct N_GIT_STATUS_ENTRY Struct N_GUI_BUTTON_DATA Struct N_GUI_CHECKBOX_DATA Struct N_GUI_COLOR_PICKER Struct N_GUI_COMBOBOX_DATA Struct N_GUI_CTX Struct N_GUI_CUSTOM_DATA Struct N_GUI_DATAGRID_COL Struct N_GUI_DATAGRID_DATA Struct N_GUI_DROPMENU_DATA Struct N_GUI_DROPMENU_ENTRY Struct N_GUI_GRID_CALLBACKS Struct N_GUI_HEXVIEW_DATA Struct N_GUI_IMAGE_DATA Struct N_GUI_KVTABLE Struct N_GUI_KV_CONTENT Struct N_GUI_KV_ROW Struct N_GUI_LABEL_DATA Struct N_GUI_LISTBOX_DATA Struct N_GUI_LISTITEM Struct N_GUI_MARKDOWNVIEW_DATA Struct N_GUI_MD_FONTS Struct N_GUI_MD_STYLE Struct N_GUI_MEAS_ENTRY Struct N_GUI_MOUSE_EVENT Struct N_GUI_PENDING_GEOM Struct N_GUI_PENDING_WIDGET Struct N_GUI_POPUP Struct N_GUI_PROGRESSBAR_DATA Struct N_GUI_RADIOLIST_DATA Struct N_GUI_SB_TRACK Struct N_GUI_SCROLLBAR_DATA Struct N_GUI_SECTION Struct N_GUI_SECTIONLIST Struct N_GUI_SLIDER_DATA Struct N_GUI_SPLITPANE_DATA Struct N_GUI_STYLE Struct N_GUI_SUGGEST_SINK Struct N_GUI_SYNTAXVIEW_DATA Struct N_GUI_TAB_PANEL Struct N_GUI_TB_BUTTONS Struct N_GUI_TEXTAREA_DATA Struct N_GUI_TEXT_DIMS Struct N_GUI_THEME Struct N_GUI_TREE Struct N_GUI_TREE_NODE Struct N_GUI_TREE_STATE Struct N_GUI_WIDGET Struct N_GUI_WINDOW Struct N_H2_FRAME Struct N_H2_HEADER Struct N_H2_HPACK Struct N_H2_REQUEST Struct N_H2_SERVER Struct N_H2_SETTING Struct N_HTML_ATTR_ Struct N_HTML_FORM Struct N_HTML_TAG_ Struct N_HTTP3_RESPONSE Struct N_HTTP_FIELD Struct N_HTTP_FORM Struct N_HTTP_FORM_MULTIPART Struct N_HTTP_FORM_PART Struct N_HTTP_MULTIPART_PART Struct N_HTTP_REQUEST Struct N_HTTP_RESP Struct N_HTTP_RESPONSE Struct N_HTTP_SERVER Struct N_HTTP_SERVER_CONFIG Struct N_HTTP_SERVER_REQUEST Struct N_HTTP_SERVER_STATS Struct N_HTTP_SET_COOKIE Struct N_HTTP_STREAM Struct N_ISO_CAMERA Struct N_ISO_OBJECT Struct N_KAFKA Struct N_KAFKA_EVENT Struct N_MOCK_SERVER Struct N_MODULE Struct N_PARALLEL_SLICE Struct N_PARALLEL_TEAM Struct N_PARALLEL_WORKER Struct N_PCRE Struct N_PROXY_CFG Struct N_PTH Struct N_PTH_TENSOR Struct N_QUERY Struct N_ROUTE Struct N_ROUTER Struct N_ROUTE_MATCH Struct N_SHA256 Struct N_SOCKET Struct N_SPAWN_PIPE Struct N_SSE_CONN Struct N_SSE_EVENT Struct N_STR Struct N_TIFF Struct N_TIFF_ENTRY Struct N_TIME Struct N_URL Struct N_URL_PARAM Struct N_USER Struct N_USERLIST Struct N_WS_CONN Struct N_WS_FRAME Struct N_WS_MESSAGE Struct N_ZIP_MEMBER Struct OCTREE Struct OCTREE_NODE Struct PARSER Struct PARTICLE Struct PARTICLE_EMITTER Struct PARTICLE_SYSTEM Struct PEER Struct PHYSICS Struct PK_OBJ Struct PK_VM Struct POINT2D Struct POINT3D Struct PRETTY_OUT Struct QNODE Struct QUADTREE Struct QUADTREE_NODE Struct REC Struct RGB Struct SAMPLE Struct SEEN Struct SHARER Struct SRV Struct SRV_ARG Struct STACK Struct STACK_ITEM Struct SYNTAX_RUN Struct THREAD_POOL Struct THREAD_POOL_NODE Struct THREAD_WAITING_PROC Struct TRAJECTORY Struct TRAJECTORY_POINT Struct TREE Struct TREE_NODE Struct TS_LOG Struct WAYPOINT3D Struct WORKER_ARG Struct ZIP_SINK Struct _N_DC_ENTRY Struct _N_DC_GROUP_ENTRY Struct _N_GUI_COLORWHEEL Struct _N_GUI_COLORWHEEL_BLOCK Struct _N_GUI_COLORWHEEL_MOUSE Struct _N_GUI_CURVE Struct _N_GUI_CURVE_BLOCK Struct _N_GUI_CURVE_MOUSE Struct _N_GUI_GRID Struct _N_GUI_POPUP_ENTRY Struct _N_GUI_POPUP_LEVEL Struct _N_GUI_SB_SKIN Struct _N_GUI_TA_STEP Struct _N_GUI_THUMB Struct _N_GUI_WRAP_ACC Struct _compiled Struct _conn Struct _ip_slot Struct _mp_param Struct _n_civil Struct _seg Struct client Struct collector Struct date_vector Struct md_atom Struct md_cells Struct md_hit Struct md_line_ctx Struct mline Struct n_http_req_header Struct n_http_req_limits Struct n_http_request Struct n_markdown_block Struct n_markdown_doc Struct n_markdown_inline Struct n_markdown_span Struct n_reactor_stats Struct n_url_safe Struct n_url_safe_head Struct n_wrap_item Struct producer_state Struct rects Struct reply Struct runner Struct sink Struct tbuf Struct wrap_hit Struct wrap_span Structures Union COORD_VALUE Union HASH_DATA Union NODE_DATA_TYPES Union STACK_DATA dir_310dcdd4703e877a6b99d5dc3fc54d27 dir_68267d1309a1af8e8297ef4c3efbcdba dir_d28a4824dc47e487b107a5db32ef43c4 dir_d44c64559bbebec7f509842c48db8b23 ex__accept__pool__client_8c ex__accept__pool__server_8c ex__allegro__4_8c ex__atlas_8c ex__avro_8c ex__base64_8c ex__bind__exclusive_8c ex__clipboard_8c ex__clock__sync_8c ex__common_8c ex__configfile_8c ex__cookies_8c ex__crypto_8c ex__diff_8c ex__digest_8c ex__disk__cache_8c ex__dns_8c ex__ecc_8c ex__entropy_8c ex__exceptions_8c ex__file_8c ex__file__copy_8c ex__fluid_8c ex__fluid__config_8c ex__fluid__config_8h ex__git_8c ex__gui_8c ex__gui__bench_8c ex__gui__button__keys_8c ex__gui__checkbox__label_8c ex__gui__checkbox__release_8c ex__gui__color__picker_8c ex__gui__colorwheel_8c ex__gui__combobox__items_8c ex__gui__combobox__wheel_8c ex__gui__cursor_8c ex__gui__curve_8c ex__gui__custom_8c ex__gui__custom__mouse_8c ex__gui__datagrid_8c ex__gui__datagrid__keys_8c ex__gui__datagrid__sort_8c ex__gui__detach_8c ex__gui__dictionary_8c ex__gui__display__fallback_8c ex__gui__double__click_8c ex__gui__dropmenu_8c ex__gui__frameless__drag_8c ex__gui__global__scroll_8c ex__gui__glyph_8c ex__gui__grid_8c ex__gui__hexview_8c ex__gui__hover_8c ex__gui__isometric_8c ex__gui__kvtable_8c ex__gui__label__fits_8c ex__gui__label__lines_8c ex__gui__layout__persist_8c ex__gui__listbox_8c ex__gui__md_8c ex__gui__multiwin_8c ex__gui__network_8c ex__gui__particles_8c ex__gui__placeholder_8c ex__gui__popup_8c ex__gui__progressbar_8c ex__gui__reentrant_8c ex__gui__round_8c ex__gui__sectionlist_8c ex__gui__slider__default_8c ex__gui__slider__handle_8c ex__gui__slider__step_8c ex__gui__splitpane_8c ex__gui__suggest_8c ex__gui__syntaxview_8c ex__gui__text__shorten_8c ex__gui__textarea__selection_8c ex__gui__tooltip_8c ex__gui__tree__lazy_8c ex__gui__tree__order_8c ex__gui__tree__state_8c ex__gui__window__rect_8c ex__gui__zorder_8c ex__hash_8c ex__hex_8c ex__html_8c ex__http2_8c ex__http2__server_8c ex__http3_8c ex__http__cookie_8c ex__http__form_8c ex__http__mime_8c ex__http__req_8c ex__http__response_8c ex__http__router_8c ex__http__server_8c ex__icc_8c ex__iso__astar_8c ex__json_8c ex__kafka_8c ex__linalg_8c ex__list_8c ex__log_8c ex__markdown_8c ex__module_8c ex__monolith_8c ex__network_8c ex__network_8h ex__network__accept_8c ex__network__alpn_8c ex__network__connect__abort_8c ex__network__mock_8c ex__network__proxy_8c ex__network__reactor_8c ex__network__sni_8c ex__network__sse_8c ex__network__ssl_8c ex__network__ssl__hardened_8c ex__network__ssl__hostname_8c ex__network__ssl__nonblock_8c ex__network__tls__defaults_8c ex__network__ws_8c ex__network__ws__limits_8c ex__nstr_8c ex__parallel__for_8c ex__parallel__team_8c ex__pcre_8c ex__pretty_8c ex__pth_8c ex__query_8c ex__random_8c ex__sha256_8c ex__signals_8c ex__spawn_8c ex__ssrf_8c ex__stack_8c ex__thread__pool__discard_8c ex__thread__pool__wait_8c ex__threads_8c ex__tiff_8c ex__time__formats_8c ex__trajectory_8c ex__trees_8c ex__url_8c ex__url__safe_8c ex__wrap_8c ex__x509_8c ex__zip_8c ex__zlib_8c ex_accept_pool_client_8c example ex_accept_pool_server_8c example ex_allegro_4_8c example ex_atlas_8c example ex_base64_8c example ex_clock_sync_8c example ex_common_8c example ex_configfile_8c example ex_cookies_8c example ex_crypto_8c example ex_diff_8c example ex_digest_8c example ex_disk_cache_8c example ex_dns_8c example ex_ecc_8c example ex_entropy_8c example ex_exceptions_8c example ex_file_8c example ex_file_copy_8c example ex_fluid_8c example ex_fluid_config_8c example ex_fluid_config_8h example ex_git_8c example ex_gui_8c example ex_gui_bench_8c example ex_gui_button_keys_8c example ex_gui_checkbox_label_8c example ex_gui_checkbox_release_8c example ex_gui_color_picker_8c example ex_gui_colorwheel_8c example ex_gui_combobox_items_8c example ex_gui_combobox_wheel_8c example ex_gui_cursor_8c example ex_gui_curve_8c example ex_gui_custom_8c example ex_gui_custom_mouse_8c example ex_gui_datagrid_8c example ex_gui_datagrid_keys_8c example ex_gui_datagrid_sort_8c example ex_gui_detach_8c example ex_gui_dictionary_8c example ex_gui_display_fallback_8c example ex_gui_double_click_8c example ex_gui_dropmenu_8c example ex_gui_frameless_drag_8c example ex_gui_global_scroll_8c example ex_gui_glyph_8c example ex_gui_grid_8c example ex_gui_hexview_8c example ex_gui_hover_8c example ex_gui_isometric_8c example ex_gui_kvtable_8c example ex_gui_label_fits_8c example ex_gui_label_lines_8c example ex_gui_layout_persist_8c example ex_gui_listbox_8c example ex_gui_md_8c example ex_gui_multiwin_8c example ex_gui_network_8c example ex_gui_particles_8c example ex_gui_placeholder_8c example ex_gui_popup_8c example ex_gui_progressbar_8c example ex_gui_reentrant_8c example ex_gui_round_8c example ex_gui_sectionlist_8c example ex_gui_slider_default_8c example ex_gui_slider_handle_8c example ex_gui_slider_step_8c example ex_gui_splitpane_8c example ex_gui_suggest_8c example ex_gui_syntaxview_8c example ex_gui_text_shorten_8c example ex_gui_textarea_selection_8c example ex_gui_tooltip_8c example ex_gui_tree_lazy_8c example ex_gui_tree_order_8c example ex_gui_tree_state_8c example ex_gui_window_rect_8c example ex_gui_zorder_8c example ex_hash_8c example ex_hex_8c example ex_html_8c example ex_http2_8c example ex_http2_server_8c example ex_http_cookie_8c example ex_http_form_8c example ex_http_mime_8c example ex_http_req_8c example ex_http_response_8c example ex_http_router_8c example ex_http_server_8c example ex_icc_8c example ex_iso_astar_8c example ex_json_8c example ex_kafka_8c example ex_linalg_8c example ex_list_8c example ex_log_8c example ex_markdown_8c example ex_module_8c example ex_monolith_8c example ex_network_8c example ex_network_8h example ex_network_accept_8c example ex_network_alpn_8c example ex_network_connect_abort_8c example ex_network_mock_8c example ex_network_proxy_8c example ex_network_reactor_8c example ex_network_sni_8c example ex_network_sse_8c example ex_network_ssl_8c example ex_network_ssl_hardened_8c example ex_network_ssl_hostname_8c example ex_network_ssl_nonblock_8c example ex_network_tls_defaults_8c example ex_network_ws_8c example ex_network_ws_limits_8c example ex_nstr_8c example ex_parallel_for_8c example ex_parallel_team_8c example ex_pcre_8c example ex_pretty_8c example ex_pth_8c example ex_query_8c example ex_random_8c example ex_sha256_8c example ex_signals_8c example ex_spawn_8c example ex_ssrf_8c example ex_stack_8c example ex_threads_8c example ex_tiff_8c example ex_time_formats_8c example ex_trajectory_8c example ex_trees_8c example ex_url_8c example ex_url_safe_8c example ex_wrap_8c example ex_x509_8c example ex_zip_8c example ex_zlib_8c example mainpage_8dox n__3d_8c n__3d_8h n__aabb_8c n__aabb_8h n__allegro5_8c n__allegro5_8h n__allegro__4_8c n__allegro__4_8h n__anim_8c n__anim_8h n__astar_8c n__astar_8h n__atlas_8c n__atlas_8h n__avro_8c n__avro_8h n__base64_8c n__base64_8h n__clipboard_8c n__clipboard_8h n__clock__sync_8c n__clock__sync_8h n__common_8c n__common_8h n__config__file_8c n__config__file_8h n__cookies_8c n__cookies_8h n__crypto_8c n__crypto_8h n__dead__reckoning_8c n__dead__reckoning_8h n__diff_8c n__diff_8h n__digest_8c n__digest_8h n__disk__cache_8c n__disk__cache_8h n__dns_8c n__dns_8h n__ecc_8c n__ecc_8h n__entropy_8c n__entropy_8h n__enum_8h n__exceptions_8c n__exceptions_8h n__files_8c n__files_8h n__fluids_8c n__fluids_8h n__games_8c n__games_8h n__git_8c n__git_8h n__gui_8c n__gui_8h n__gui__color_8c n__gui__color_8h n__gui__colorwheel_8c n__gui__colorwheel_8h n__gui__curve_8c n__gui__curve_8h n__gui__grid_8c n__gui__grid_8h n__gui__md_8c n__gui__md_8h n__gui__popup_8c n__gui__popup_8h n__hash_8c n__hash_8h n__hex_8c n__hex_8h n__html_8c n__html_8h n__http2_8c n__http2_8h n__http2__server_8c n__http2__server_8h n__http3_8c n__http3_8h n__http__cookie_8c n__http__cookie_8h n__http__form_8c n__http__form_8h n__http__mime_8c n__http__mime_8h n__http__req_8c n__http__req_8h n__http__response_8c n__http__response_8h n__http__router_8c n__http__router_8h n__http__server_8c n__http__server_8h n__icc_8c n__icc_8h n__iso__engine_8c n__iso__engine_8h n__json_8c n__json_8h n__kafka_8c n__kafka_8h n__linalg_8c n__linalg_8h n__list_8c n__list_8h n__log_8c n__log_8h n__lz4_8c n__lz4_8h n__markdown_8c n__markdown_8h n__module_8c n__module_8h n__network_8c n__network_8h n__network__accept__pool_8c n__network__accept__pool_8h n__network__msg_8c n__network__msg_8h n__nodup__log_8c n__nodup__log_8h n__openssl__compat_8h n__particles_8c n__particles_8h n__pcre_8c n__pcre_8h n__pretty_8c n__pretty_8h n__pth_8c n__pth_8h n__query_8c n__query_8h n__random_8c n__random_8h n__reactor_8c n__reactor_8h n__sha256_8c n__sha256_8h n__signals_8c n__signals_8h n__ssrf_8c n__ssrf_8h n__stack_8c n__stack_8h n__str_8c n__str_8h n__thread__pool_8c n__thread__pool_8h n__tiff_8c n__tiff_8h n__time_8c n__time_8h n__trajectory_8c n__trajectory_8h n__trees_8c n__trees_8h n__url__safe_8c n__url__safe_8h n__user_8c n__user_8h n__windows_8h n__wrap_8c n__wrap_8h n__x509_8c n__x509_8h n__zip_8c n__zip_8h n__zlib_8c n__zlib_8h nilorea_8h
6 Module HASH_TABLE
gullradriel edited this page 2026-10-29 20:54:40 +01:00
Table of Contents

HASH TABLES: classic or trie tree hash_tables

Structures

Name
struct HASH_TABLE
structure of a hash table
struct HASH_NODE
structure of a hash table node
union HASH_DATA
union of the possibles data values of a node

Types

Name
typedef size_t HASH_VALUE
type of a HASH_VALUE

Functions

Name
size_t next_prime(size_t nb)
return the next prime number greater than or equal to nb
HASH_TABLE * new_ht_trie(size_t alphabet_size, size_t alphabet_offset)
create a new trie hash table with the given alphabet size and offset
HASH_TABLE * new_ht(size_t size)
create a new classic hash table of the given size
int is_prime(size_t nb)
check if a number is prime
LIST * ht_search(HASH_TABLE * table, int(*)(HASH_NODE *node) node_is_matching)
search the hash table for nodes matching a predicate
int ht_resize(HASH_TABLE ** table, size_t size)
resize a hash table to the given size
int ht_remove_ex(HASH_TABLE * table, HASH_VALUE hash_value)
remove a node by numeric hash value
int ht_remove(HASH_TABLE * table, const char * key)
remove a node from the hash table by key
int ht_put_string_ptr(HASH_TABLE * table, const char * key, char * string)
put a string pointer into the hash table without copying
int ht_put_string(HASH_TABLE * table, const char * key, char * string)
put a string value (duplicated) into the hash table
int ht_put_ptr_ex(HASH_TABLE * table, HASH_VALUE hash_value, void * val, void(*)(void *ptr) destructor, void ()(void *ptr) duplicator)
put a pointer value by numeric hash value
int ht_put_ptr(HASH_TABLE * table, const char * key, void * ptr, void(*)(void *ptr) destructor, void ()(void *ptr) duplicator)
put a pointer value into the hash table with destructor and duplicator
int ht_put_int(HASH_TABLE * table, const char * key, int64_t value)
put an integer value into the hash table
int ht_put_double(HASH_TABLE * table, const char * key, double value)
put a double value into the hash table
void ht_print(HASH_TABLE * table)
print the contents of a hash table
int ht_optimize(HASH_TABLE ** table)
optimize a hash table by resizing to the optimal size
char * ht_node_type(const HASH_NODE * node)
return the type of a hash node as a string
int ht_get_table_collision_percentage(HASH_TABLE * table)
get the collision percentage of the hash table
int ht_get_string(HASH_TABLE * table, const char * key, char ** val)
get a string value from the hash table by key
int ht_get_ptr_ex(HASH_TABLE * table, HASH_VALUE hash_value, void ** val)
get a pointer value by numeric hash value
int ht_get_ptr(HASH_TABLE * table, const char * key, void ** val)
get a pointer value from the hash table by key
size_t ht_get_optimal_size(HASH_TABLE * table)
compute the optimal size for the hash table
HASH_NODE * ht_get_node_ex(HASH_TABLE * table, HASH_VALUE hash_value)
get a HASH_NODE by numeric hash value
HASH_NODE * ht_get_node(HASH_TABLE * table, const char * key)
get the HASH_NODE associated with the given key
int ht_get_int(HASH_TABLE * table, const char * key, int64_t * val)
get an integer value from the hash table by key
int ht_get_double(HASH_TABLE * table, const char * key, double * val)
get a double value from the hash table by key
LIST * ht_get_completion_list(HASH_TABLE * table, const char * keybud, size_t max_results)
get a list of key completions matching the given prefix
HASH_TABLE * ht_duplicate(HASH_TABLE * table)
duplicate a hash table
int empty_ht(HASH_TABLE * table)
empty a hash table, freeing all nodes
int destroy_ht(HASH_TABLE ** table)
destroy a hash table and free all resources
void MurmurHash3_x86_32(const void * key, const size_t len, const uint32_t seed, void * out)
compute a 32-bit MurmurHash3 hash
void MurmurHash3_x86_128(const void * key, const size_t len, const uint32_t seed, void * out)
compute a 128-bit MurmurHash3 hash for x86
void MurmurHash3_x64_128(const void * key, const size_t len, const uint64_t seed, void * out)
compute a 128-bit MurmurHash3 hash for x64

Defines

Name
ht_foreach_r(_ITEM, _HASH, _ITERATOR)
ForEach macro helper, reentrant (classic / old).
ht_foreach(_ITEM, _HASH)
ForEach macro helper (classic / old).
hash_val(node, type)
Cast a HASH_NODE element.
MurmurHash(__key, __len, __seed, __out)
Murmur hash macro helper 64 bits.
HT_FOREACH_R(_ITEM, _HASH, __ITERATOR, ...)
ForEach macro helper.
HT_FOREACH(_ITEM, _HASH, ...)
ForEach macro helper.
HASH_VAL(node, type)
Cast a HASH_NODE element.
HASH_UNKNOWN
value of unknow type inside the hash node
HASH_TRIE
TRIE tree using hash key string.
HASH_STRING
value of char * type inside the hash node
HASH_PTR
value of pointer type inside the hash node
HASH_INT_TYPE
type of a HASH_INT in 64 bits
HASH_INT
compatibility with existing rot func
HASH_DOUBLE
value of double type inside the hash node
HASH_CLASSIC
Murmur hash using hash key string, hash key numeric value, index table with lists of elements.

Types Documentation

typedef HASH_VALUE

typedef size_t HASH_VALUE;

type of a HASH_VALUE

Functions Documentation

function next_prime

size_t next_prime(
    size_t nb
)

return the next prime number greater than or equal to nb

Parameters:

  • nb number to test

Return: next prime number after nb or FALSE

compute next prime number after nb

return the next prime number greater than or equal to nb

function new_ht_trie

HASH_TABLE * new_ht_trie(
    size_t alphabet_size,
    size_t alphabet_offset
)

create a new trie hash table with the given alphabet size and offset

Parameters:

  • alphabet_length of the alphabet
  • alphabet_offset offset of each character in a key (i.e: to have 'a->z' with 'a' starting at zero, offset must be 32.

Return: NULL or the new allocated hash table

create a TRIE hash table with the alphabet_size, each key value beeing decreased by alphabet_offset

create a new trie hash table with the given alphabet size and offset

function new_ht

HASH_TABLE * new_ht(
    size_t size
)

create a new classic hash table of the given size

Parameters:

  • size Size of the root hash node table

Return: NULL or the new allocated hash table

Create a hash table with the given size.

create a new classic hash table of the given size

function is_prime

int is_prime(
    size_t nb
)

check if a number is prime

Parameters:

  • nb number to test

Return: TRUE or FALSE

test if number is a prime number or not

check if a number is prime

function ht_search

LIST * ht_search(
    HASH_TABLE * table,
    int(*)(HASH_NODE *node) node_is_matching
)

search the hash table for nodes matching a predicate

Parameters:

  • table targeted hash table
  • node_is_matching matching function

Return: NULL or a LIST *list of HASH_NODE *nodes

seach table for matching nodes

search the hash table for nodes matching a predicate

function ht_resize

int ht_resize(
    HASH_TABLE ** table,
    size_t size
)

resize a hash table to the given size

Parameters:

  • table targeted table
  • size new hash table size

Return: TRUE or FALSE

rehash table according to size (HASH_CLASSIC mode only)

resize a hash table to the given size

function ht_remove_ex

int ht_remove_ex(
    HASH_TABLE * table,
    HASH_VALUE hash_value
)

remove a node by numeric hash value

Parameters:

  • table Targeted hash table
  • hash_value key pre computed numeric hash value

Return: TRUE or FALSE.

Remove a key from a hash table (HASH_CLASSIC only).

remove a node by numeric hash value

function ht_remove

int ht_remove(
    HASH_TABLE * table,
    const char * key
)

remove a node from the hash table by key

Parameters:

  • table targeted hash table
  • key key of node to destroy

Return: TRUE or FALSE

remove and delete node at key in table

remove a node from the hash table by key

function ht_put_string_ptr

int ht_put_string_ptr(
    HASH_TABLE * table,
    const char * key,
    char * string
)

put a string pointer into the hash table without copying

Parameters:

  • table targeted hash table
  • key associated value's key
  • string string value to put (pointer)

Return: TRUE or FALSE

put a string value (pointer) with given key in the targeted hash table

put a string pointer into the hash table without copying

function ht_put_string

int ht_put_string(
    HASH_TABLE * table,
    const char * key,
    char * string
)

put a string value (duplicated) into the hash table

Parameters:

  • table targeted hash table
  • key associated value's key
  • string string value to put (copy)

Return: TRUE or FALSE

put a string value (copy/dup) with given key in the targeted hash table

put a string value (duplicated) into the hash table

function ht_put_ptr_ex

int ht_put_ptr_ex(
    HASH_TABLE * table,
    HASH_VALUE hash_value,
    void * val,
    void(*)(void *ptr) destructor,
    void *(*)(void *ptr) duplicator
)

put a pointer value by numeric hash value

Parameters:

  • table targeted hash table
  • hash_value precomputed hash value for the key
  • val pointer value to put
  • destructor Pointer to the ptr type destructor function. Leave to NULL if there isn't
  • duplicator Pointer to the ptr type duplicator function. Leave to NULL if there isn't

Return: TRUE or FALSE

put a pointer value with given key in the targeted hash table (HASH_CLASSIC only)

put a pointer value by numeric hash value

function ht_put_ptr

int ht_put_ptr(
    HASH_TABLE * table,
    const char * key,
    void * ptr,
    void(*)(void *ptr) destructor,
    void *(*)(void *ptr) duplicator
)

put a pointer value into the hash table with destructor and duplicator

Parameters:

  • table targeted hash table
  • key key of the entry
  • ptr pointer value to put
  • destructor Pointer to the ptr type destructor function. Leave to NULL if there isn't
  • duplicator Pointer to the ptr type duplicator function. Leave to NULL if there isn't

Return: TRUE or FALSE

put an arbitrary pointer value with given key in the targeted hash table

put a pointer value into the hash table with destructor and duplicator

function ht_put_int

int ht_put_int(
    HASH_TABLE * table,
    const char * key,
    int64_t value
)

put an integer value into the hash table

Parameters:

  • table targeted hash table
  • key associated value's key
  • value integral value to put

Return: TRUE or FALSE

put an integral value with given key in the targeted hash table

put an integer value into the hash table

function ht_put_double

int ht_put_double(
    HASH_TABLE * table,
    const char * key,
    double value
)

put a double value into the hash table

Parameters:

  • table targeted table
  • key key to retrieve
  • value double value to put

Return: TRUE or FALSE

put a double value with given key in the targeted hash table

put a double value into the hash table

function ht_print

void ht_print(
    HASH_TABLE * table
)

print the contents of a hash table

Parameters:

  • table targeted hash table

print contents of table

print the contents of a hash table

function ht_optimize

int ht_optimize(
    HASH_TABLE ** table
)

optimize a hash table by resizing to the optimal size

Parameters:

  • table targeted table

Return: TRUE or FALSE and set table to NULL

try an automatic optimization of the table (HASH_CLASSIC mode only)

optimize a hash table by resizing to the optimal size

function ht_node_type

char * ht_node_type(
    const HASH_NODE * node
)

return the type of a hash node as a string

Parameters:

  • node node to check

Return: "HASH_INT", "HASH_DOUBLE", "HASH_STRING", "HASH_PTR", "HASH_UNKNOWN", "NULL_NODE"

get the type of a node , text version

return the type of a hash node as a string

function ht_get_table_collision_percentage

int ht_get_table_collision_percentage(
    HASH_TABLE * table
)

get the collision percentage of the hash table

Parameters:

  • table targeted table

Return: table collision percentage or FALSE

get table collision percentage (HASH_CLASSIC mode only)

get the collision percentage of the hash table

function ht_get_string

int ht_get_string(
    HASH_TABLE * table,
    const char * key,
    char ** val
)

get a string value from the hash table by key

Parameters:

  • table targeted table
  • key key to retrieve
  • val pointer to string storage

Return: TRUE if found, else FALSE. 'val' value is preserved if no key is matching.

get string at 'key' from 'table'

get a string value from the hash table by key

function ht_get_ptr_ex

int ht_get_ptr_ex(
    HASH_TABLE * table,
    HASH_VALUE hash_value,
    void ** val
)

get a pointer value by numeric hash value

Parameters:

  • table Targeted hash table
  • hash_value key pre computed numeric hash value
  • val A pointer to an empty pointer store

Return: TRUE or FALSE.

Retrieve a pointer value in the hash table, at the given key.

get a pointer value by numeric hash value

Leave val untouched if key is not found. (HASH_CLASSIC only)

function ht_get_ptr

int ht_get_ptr(
    HASH_TABLE * table,
    const char * key,
    void ** val
)

get a pointer value from the hash table by key

Parameters:

  • table targeted table
  • key key to retrieve
  • val pointer to pointer storage

Return: TRUE if found, else FALSE. 'val' value is preserved if no key is matching.

get pointer at 'key' from 'table'

get a pointer value from the hash table by key

function ht_get_optimal_size

size_t ht_get_optimal_size(
    HASH_TABLE * table
)

compute the optimal size for the hash table

Parameters:

  • table targeted table

Return: 0 or optimal table size

get optimal array size based on nb=(number_of_key*1.3) && if( !isprime(nb) )nb=nextprime(nb) (HASH_CLASSIC mode only)

compute the optimal size for the hash table

function ht_get_node_ex

HASH_NODE * ht_get_node_ex(
    HASH_TABLE * table,
    HASH_VALUE hash_value
)

get a HASH_NODE by numeric hash value

Parameters:

  • table Targeted hash table
  • hash_value Associated hash_value

Return: The found node, or NULL

return the associated key's node inside the hash_table (HASH_CLASSIC only)

get a HASH_NODE by numeric hash value

function ht_get_node

HASH_NODE * ht_get_node(
    HASH_TABLE * table,
    const char * key
)

get the HASH_NODE associated with the given key

Parameters:

  • table targeted table
  • key key to retrieve

Return: NULL or the matching HASH_NODE *node

get node at 'key' from 'table'

get the HASH_NODE associated with the given key

function ht_get_int

int ht_get_int(
    HASH_TABLE * table,
    const char * key,
    int64_t * val
)

get an integer value from the hash table by key

Parameters:

  • table targeted table
  • key key to retrieve
  • val pointer to int storage

Return: TRUE if found, else FALSE. 'val' value is preserved if no key is matching.

get node at 'key' from 'table'

get an integer value from the hash table by key

function ht_get_double

int ht_get_double(
    HASH_TABLE * table,
    const char * key,
    double * val
)

get a double value from the hash table by key

Parameters:

  • table targeted table
  • key key to retrieve
  • val pointer to double storage

Return: TRUE if found, else FALSE. 'val' value is preserved if no key is matching.

get double at 'key' from 'table'

get a double value from the hash table by key

function ht_get_completion_list

LIST * ht_get_completion_list(
    HASH_TABLE * table,
    const char * keybud,
    size_t max_results
)

get a list of key completions matching the given prefix

Parameters:

  • table targeted hash table
  • keybud starting characters of the keys we want
  • max_results maximum number of matching keys in list. From UNLIMITED_LIST_ITEMS (0) to MAX_LIST_ITEMS (SIZE_MAX).

Return: NULL or a LIST *list of matching HASH_NODE *nodes

get next matching keys in table tree

get a list of key completions matching the given prefix

function ht_duplicate

HASH_TABLE * ht_duplicate(
    HASH_TABLE * table
)

duplicate a hash table

Parameters:

Return: NULL or and allocated duplicated HASH_TABLE

duplicate a hash table (all pointers should have a duplicator func set)

duplicate a hash table

function empty_ht

int empty_ht(
    HASH_TABLE * table
)

empty a hash table, freeing all nodes

Parameters:

  • table targeted hash table

Return: TRUE or FALSE

empty a table

empty a hash table, freeing all nodes

function destroy_ht

int destroy_ht(
    HASH_TABLE ** table
)

destroy a hash table and free all resources

Parameters:

  • table targeted hash table

Return: TRUE or FALSE

empty a table and destroy it

destroy a hash table and free all resources

function MurmurHash3_x86_32

void MurmurHash3_x86_32(
    const void * key,
    const size_t len,
    const uint32_t seed,
    void * out
)

compute a 32-bit MurmurHash3 hash

Parameters:

  • key char *string as the key
  • len size of the key
  • seed seed value for murmur hash
  • out generated hash

MurmurHash3 was written by Austin Appleby, and is placed in the public domain.

compute a 32-bit MurmurHash3 hash

The author hereby disclaims copyright to this source code. Note - The x86 and x64 versions do not produce the same results, as the algorithms are optimized for their respective platforms. You can still compile and run any of them on any platform, but your performance with the non-native version will be less than optimal.

function MurmurHash3_x86_128

void MurmurHash3_x86_128(
    const void * key,
    const size_t len,
    const uint32_t seed,
    void * out
)

compute a 128-bit MurmurHash3 hash for x86

Parameters:

  • key char *string as the key
  • len size of the key
  • seed seed value for murmur hash
  • out generated hash

MurmurHash3 was written by Austin Appleby, and is placed in the public domain.

compute a 128-bit MurmurHash3 hash for x86

The author hereby disclaims copyright to this source code. Note - The x86 and x64 versions do not produce the same results, as the algorithms are optimized for their respective platforms. You can still compile and run any of them on any platform, but your performance with the non-native version will be less than optimal.

function MurmurHash3_x64_128

void MurmurHash3_x64_128(
    const void * key,
    const size_t len,
    const uint64_t seed,
    void * out
)

compute a 128-bit MurmurHash3 hash for x64

Parameters:

  • key char *string as the key
  • len size of the key
  • seed seed value for murmur hash
  • out generated hash

MurmurHash3 was written by Austin Appleby, and is placed in the public domain.

compute a 128-bit MurmurHash3 hash for x64

The author hereby disclaims copyright to this source code. Note - The x86 and x64 versions do not produce the same results, as the algorithms are optimized for their respective platforms. You can still compile and run any of them on any platform, but your performance with the non-native version will be less than optimal.

Macros Documentation

define ht_foreach_r

#define ht_foreach_r(
    __ITEM_,
    __HASH_,
    __ITERATOR_
)
if (!__HASH_) {                                                                      \
    n_log(LOG_ERR, "Error in ht_foreach, %s is NULL", #__HASH_);                     \
} else if (__HASH_->mode != HASH_CLASSIC) {                                          \
    n_log(LOG_ERR, "Error in ht_foreach, %d is an unsupported mode", __HASH_->mode); \
} else                                                                               \
    for (size_t __ITERATOR_ = 0; __ITERATOR_ < __HASH_->size; __ITERATOR_++)         \
        for (LIST_NODE* __ITEM_ = __HASH_->hash_table[__ITERATOR_]->start; __ITEM_ != NULL; __ITEM_ = __ITEM_->next)

ForEach macro helper, reentrant (classic / old).

define ht_foreach

#define ht_foreach(
    __ITEM_,
    __HASH_
)
if (!__HASH_) {                                                                                               \
    n_log(LOG_ERR, "Error in ht_foreach, %s is NULL", #__HASH_);                                              \
} else if (__HASH_->mode != HASH_CLASSIC) {                                                                   \
    n_log(LOG_ERR, "Error in ht_foreach( %s , %s ) unsupportted mode %d", #__ITEM_, #__HASH_, __HASH_->mode); \
} else                                                                                                        \
    for (size_t __hash_it = 0; __hash_it < __HASH_->size; __hash_it++)                                        \
        for (LIST_NODE* __ITEM_ = __HASH_->hash_table[__hash_it]->start; __ITEM_ != NULL; __ITEM_ = __ITEM_->next)

ForEach macro helper (classic / old).

define hash_val

#define hash_val(
    node,
    type
)
((node && node->ptr) ? ((type*)(((HASH_NODE*)node->ptr)->data.ptr)) : NULL)

Cast a HASH_NODE element.

define MurmurHash

#define MurmurHash(
    __key,
    __len,
    __seed,
    __out
)
MurmurHash3_x64_128(__key, __len, __seed, __out)

Murmur hash macro helper 64 bits.

define HT_FOREACH_R

#define HT_FOREACH_R(
    __ITEM_,
    __HASH_,
    __ITERATOR,
    ...
)
{                                                                                                                                                                                                                                  \
    do {                                                                                                                                                                                                                           \
        if (!__HASH_) {                                                                                                                                                                                                            \
            n_log(LOG_ERR, "Error in ht_foreach, %s is NULL", #__HASH_);                                                                                                                                                           \
        } else {                                                                                                                                                                                                                   \
            if (__HASH_->mode == HASH_CLASSIC) {                                                                                                                                                                                   \
                int CONCAT(__ht_node_trie_func_macro_break_flag_classic, __LINE__) = 0;                                                                                                                                            \
                LIST_NODE* CONCAT(__ht_list_node_r, __LINE__) = NULL;                                                                                                                                                              \
                for (size_t __ITERATOR = 0; __ITERATOR < __HASH_->size; __ITERATOR++) {                                                                                                                                            \
                    for (CONCAT(__ht_list_node_r, __LINE__) = __HASH_->hash_table[__ITERATOR]->start; CONCAT(__ht_list_node_r, __LINE__) != NULL; CONCAT(__ht_list_node_r, __LINE__) = CONCAT(__ht_list_node_r, __LINE__)->next) { \
                        HASH_NODE* __ITEM_ = (HASH_NODE*)CONCAT(__ht_list_node_r, __LINE__)->ptr;                                                                                                                                  \
                        CONCAT(__ht_node_trie_func_macro_break_flag_classic, __LINE__) = 1;                                                                                                                                        \
                        __VA_ARGS__                                                                                                                                                                                                \
                        CONCAT(__ht_node_trie_func_macro_break_flag_classic, __LINE__) = 0;                                                                                                                                        \
                    }                                                                                                                                                                                                              \
                    if (CONCAT(__ht_node_trie_func_macro_break_flag_classic, __LINE__) == 1)                                                                                                                                       \
                        break;                                                                                                                                                                                                     \
                }                                                                                                                                                                                                                  \
            } else if (__HASH_->mode == HASH_TRIE) {                                                                                                                                                                               \
                int CONCAT(__ht_node_trie_func_macro, __LINE__)(HASH_NODE * __ITEM_) {                                                                                                                                             \
                    if (!__ITEM_) return TRUE;                                                                                                                                                                                     \
                    int CONCAT(__ht_node_trie_func_macro_break_flag, __LINE__) = 1;                                                                                                                                                \
                    if (__ITEM_->is_leaf) {                                                                                                                                                                                        \
                        do {                                                                                                                                                                                                       \
                            __VA_ARGS__                                                                                                                                                                                            \
                            CONCAT(__ht_node_trie_func_macro_break_flag, __LINE__) = 0;                                                                                                                                            \
                        } while (0);                                                                                                                                                                                               \
                    }                                                                                                                                                                                                              \
                    if (CONCAT(__ht_node_trie_func_macro_break_flag, __LINE__) == 1) return FALSE;                                                                                                                                 \
                    for (size_t it = 0; it < __ITEM_->alphabet_length; it++) {                                                                                                                                                     \
                        if (CONCAT(__ht_node_trie_func_macro, __LINE__)(__ITEM_->children[it]) == FALSE)                                                                                                                           \
                            return FALSE;                                                                                                                                                                                          \
                    }                                                                                                                                                                                                              \
                    return TRUE;                                                                                                                                                                                                   \
                }                                                                                                                                                                                                                  \
                CONCAT(__ht_node_trie_func_macro, __LINE__)                                                                                                                                                                        \
                (__HASH_->root);                                                                                                                                                                                                   \
            } else {                                                                                                                                                                                                               \
                n_log(LOG_ERR, "Error in ht_foreach, %d is an unsupported mode", __HASH_->mode);                                                                                                                                   \
                break;                                                                                                                                                                                                             \
            }                                                                                                                                                                                                                      \
        }                                                                                                                                                                                                                          \
    } while (0);                                                                                                                                                                                                                   \
}

ForEach macro helper.

define HT_FOREACH

#define HT_FOREACH(
    __ITEM_,
    __HASH_,
    ...
)
{                                                                                                                                                                                                \
    do {                                                                                                                                                                                         \
        if (!__HASH_) {                                                                                                                                                                          \
            n_log(LOG_ERR, "Error in ht_foreach, %s is NULL", #__HASH_);                                                                                                                         \
        } else {                                                                                                                                                                                 \
            if (__HASH_->mode == HASH_CLASSIC) {                                                                                                                                                 \
                int CONCAT(__ht_node_trie_func_macro_break_flag_classic, __LINE__) = 0;                                                                                                          \
                for (size_t __hash_it = 0; __hash_it < __HASH_->size; __hash_it++) {                                                                                                             \
                    for (LIST_NODE* __ht_list_node = __HASH_->hash_table[__hash_it]->start; __ht_list_node != NULL; __ht_list_node = __ht_list_node->next) {                                     \
                        HASH_NODE* __ITEM_ = (HASH_NODE*)__ht_list_node->ptr;                                                                                                                    \
                        CONCAT(__ht_node_trie_func_macro_break_flag_classic, __LINE__) = 1;                                                                                                      \
                        __VA_ARGS__                                                                                                                                                              \
                        CONCAT(__ht_node_trie_func_macro_break_flag_classic, __LINE__) = 0;                                                                                                      \
                    }                                                                                                                                                                            \
                    if (CONCAT(__ht_node_trie_func_macro_break_flag_classic, __LINE__) == 1)                                                                                                     \
                        break;                                                                                                                                                                   \
                }                                                                                                                                                                                \
            } else if (__HASH_->mode == HASH_TRIE) {                                                                                                                                             \
                int CONCAT(__ht_node_trie_func_macro, __LINE__)(HASH_NODE * __ITEM_) {                                                                                                           \
                    if (!__ITEM_) return TRUE;                                                                                                                                                   \
                    int CONCAT(__ht_node_trie_func_macro_break_flag, __LINE__) = 1;                                                                                                              \
                    if (__ITEM_->is_leaf) {                                                                                                                                                      \
                        do {                                                                                                                                                                     \
                            __VA_ARGS__                                                                                                                                                          \
                            CONCAT(__ht_node_trie_func_macro_break_flag, __LINE__) = 0;                                                                                                          \
                        } while (0);                                                                                                                                                             \
                    }                                                                                                                                                                            \
                    if (CONCAT(__ht_node_trie_func_macro_break_flag, __LINE__) == 1) return FALSE;                                                                                               \
                    for (size_t CONCAT(__ht_node_trie_func_it, __LINE__) = 0; CONCAT(__ht_node_trie_func_it, __LINE__) < __ITEM_->alphabet_length; CONCAT(__ht_node_trie_func_it, __LINE__)++) { \
                        if (CONCAT(__ht_node_trie_func_macro, __LINE__)(__ITEM_->children[CONCAT(__ht_node_trie_func_it, __LINE__)]) == FALSE)                                                   \
                            return FALSE;                                                                                                                                                        \
                    }                                                                                                                                                                            \
                    return TRUE;                                                                                                                                                                 \
                }                                                                                                                                                                                \
                CONCAT(__ht_node_trie_func_macro, __LINE__)                                                                                                                                      \
                (__HASH_->root);                                                                                                                                                                 \
            } else {                                                                                                                                                                             \
                n_log(LOG_ERR, "Error in ht_foreach, %d is an unsupported mode", __HASH_->mode);                                                                                                 \
                break;                                                                                                                                                                           \
            }                                                                                                                                                                                    \
        }                                                                                                                                                                                        \
    } while (0);                                                                                                                                                                                 \
}

ForEach macro helper.

define HASH_VAL

#define HASH_VAL(
    node,
    type
)
((node && node->data.ptr) ? ((type*)node->data.ptr) : NULL)

Cast a HASH_NODE element.

define HASH_UNKNOWN

#define HASH_UNKNOWN 16

value of unknow type inside the hash node

define HASH_TRIE

#define HASH_TRIE 256

TRIE tree using hash key string.

define HASH_STRING

#define HASH_STRING 4

value of char * type inside the hash node

define HASH_PTR

#define HASH_PTR 8

value of pointer type inside the hash node

define HASH_INT_TYPE

#define HASH_INT_TYPE int64_t

type of a HASH_INT in 64 bits

define HASH_INT

#define HASH_INT 1

compatibility with existing rot func

compatibility with existing rot func

compatibility with existing func

missing ROTL fix 32bit

missing ROTL fix 64bit

missing ROTL constant

value of integral type inside the hash node

define HASH_DOUBLE

#define HASH_DOUBLE 2

value of double type inside the hash node

define HASH_CLASSIC

#define HASH_CLASSIC 128

Murmur hash using hash key string, hash key numeric value, index table with lists of elements.

Home

Modules