// Copyright (c) Epic Games Tools // Licensed under the MIT license (https://opensource.org/license/mit/) internal void bucket_list_concat_in_place(BucketList *list, BucketList *to_concat) { if (to_concat->first) { if (list->first) { list->last->next = to_concat->first; list->last = to_concat->last; } else { list->first = to_concat->first; list->last = to_concat->last; } MemoryZeroStruct(to_concat); } } internal BucketNode * bucket_list_pop(BucketList *list) { BucketNode *result = list->first; SLLQueuePop(list->first, list->last); return result; } internal U64 hash_table_hasher(String8 string) { return u64_hash_from_str8(string); } internal HashTable * hash_table_init(Arena *arena, U64 cap) { HashTable *ht = push_array(arena, HashTable, 1); ht->cap = cap; ht->buckets = push_array(arena, BucketList, cap); return ht; } internal void hash_table_purge(HashTable *ht) { // reset key count ht->count = 0; // concat buckets for (U64 ibucket = 0; ibucket < ht->cap; ++ibucket) { bucket_list_concat_in_place(&ht->free_buckets, &ht->buckets[ibucket]); } } internal BucketNode * hash_table_push(Arena *arena, HashTable *ht, U64 hash, KeyValuePair v) { BucketNode *node; if (ht->free_buckets.first != 0) { node = bucket_list_pop(&ht->free_buckets); } else { node = push_array(arena, BucketNode, 1); } node->next = 0; node->v = v; U64 ibucket = hash % ht->cap; DLLPushBack(ht->buckets[ibucket].first, ht->buckets[ibucket].last, node); ht->count += 1; return node; } internal BucketNode * hash_table_push_string_string(Arena *arena, HashTable *ht, String8 key, String8 value) { U64 hash = hash_table_hasher(key); return hash_table_push(arena, ht, hash, (KeyValuePair){ .key_string = key, .value_string = value }); } internal BucketNode * hash_table_push_string_raw(Arena *arena, HashTable *ht, String8 key, void *value) { U64 hash = hash_table_hasher(key); return hash_table_push(arena, ht, hash, (KeyValuePair){ .key_string = key, .value_raw = value }); } internal BucketNode * hash_table_push_string_u64(Arena *arena, HashTable *ht, String8 key, U64 value) { U64 hash = hash_table_hasher(key); return hash_table_push(arena, ht, hash, (KeyValuePair){.key_string = key, .value_u64 = value }); } internal BucketNode * hash_table_push_u32_raw(Arena *arena, HashTable *ht, U32 key, void *value) { U64 hash = hash_table_hasher(str8_struct(&key)); return hash_table_push(arena, ht, hash, (KeyValuePair){ .key_u32 = key, .value_raw = value }); } internal BucketNode * hash_table_push_u32_string(Arena *arena, HashTable *ht, U32 key, String8 value) { U64 hash = hash_table_hasher(str8_struct(&key)); return hash_table_push(arena, ht, hash, (KeyValuePair){ .key_u32 = key, .value_string = value }); } internal BucketNode * hash_table_push_u64_raw(Arena *arena, HashTable *ht, U64 key, void *value) { U64 hash = hash_table_hasher(str8_struct(&key)); return hash_table_push(arena, ht, hash, (KeyValuePair){ .key_u64 = key, .value_raw = value }); } internal BucketNode * hash_table_push_u64_string(Arena *arena, HashTable *ht, U64 key, String8 value) { U64 hash = hash_table_hasher(str8_struct(&key)); return hash_table_push(arena, ht, hash, (KeyValuePair){ .key_u64 = key, .value_string = value }); } internal BucketNode * hash_table_push_u64_u64(Arena *arena, HashTable *ht, U64 key, U64 value) { U64 hash = hash_table_hasher(str8_struct(&key)); return hash_table_push(arena, ht, hash, (KeyValuePair){ .key_u64 = key, .value_u64 = value }); } internal String8 hash_table_normalize_path_string(Arena *arena, String8 path) { Temp scratch = scratch_begin(&arena, 1); String8 result; result = lower_from_str8(scratch.arena, path); result = path_convert_slashes(arena, result, PathStyle_UnixAbsolute); scratch_end(scratch); return result; } internal BucketNode * hash_table_push_path_string(Arena *arena, HashTable *ht, String8 path, String8 value) { String8 path_canon = hash_table_normalize_path_string(arena, path); return hash_table_push_string_string(arena, ht, path_canon, value); } internal BucketNode * hash_table_push_path_u64(Arena *arena, HashTable *ht, String8 path, U64 value) { String8 path_canon = hash_table_normalize_path_string(arena, path); U64 hash = hash_table_hasher(path_canon); return hash_table_push(arena, ht, hash, (KeyValuePair){ .key_string = path_canon, .value_u64 = value }); } internal BucketNode * hash_table_push_path_raw(Arena *arena, HashTable *ht, String8 path, void *value) { String8 path_canon = hash_table_normalize_path_string(arena, path); U64 hash = hash_table_hasher(path_canon); return hash_table_push(arena, ht, hash, (KeyValuePair){ .key_string = path_canon, .value_raw = value }); } //////////////////////////////// internal BucketNode * hash_table_bucket_from_hash(HashTable *ht, U64 hash) { BucketNode *bucket = 0; if (ht->cap > 0) { bucket = ht->buckets[hash % ht->cap].first; } return bucket; } internal BucketNode * hash_table_search_string(HashTable *ht, String8 key_string) { BucketNode *bucket = hash_table_bucket_from_hash(ht, hash_table_hasher(key_string)); for EachNode(n, BucketNode, bucket) { if (str8_match(n->v.key_string, key_string, 0)) { return n; } } return 0; } internal BucketNode * hash_table_search_u32(HashTable *ht, U32 key_u32) { BucketNode *bucket = hash_table_bucket_from_hash(ht, hash_table_hasher(str8_struct(&key_u32))); for EachNode(n, BucketNode, bucket) { if (n->v.key_u32 == key_u32) { return n; } } return 0; } internal BucketNode * hash_table_search_u64(HashTable *ht, U64 key_u64) { BucketNode *bucket = hash_table_bucket_from_hash(ht, hash_table_hasher(str8_struct(&key_u64))); for EachNode(n, BucketNode, bucket) { if (n->v.key_u64 == key_u64) { return n; } } return 0; } internal BucketNode * hash_table_search_path(HashTable *ht, String8 path) { Temp scratch = scratch_begin(0,0); String8 path_canon = path; path_canon = lower_from_str8(scratch.arena, path_canon); path_canon = path_convert_slashes(scratch.arena, path_canon, PathStyle_UnixAbsolute); BucketNode *result = hash_table_search_string(ht, path_canon); scratch_end(scratch); return result; } internal BucketNode * hash_table_search_raw(HashTable *ht, void *key) { BucketNode *bucket = hash_table_bucket_from_hash(ht, hash_table_hasher(str8_struct(&key))); for EachNode(n, BucketNode, bucket) { if (n->v.key_raw == key) { return n; } } return 0; } internal B32 hash_table_search_path_u64(HashTable *ht, String8 key, U64 *value_out) { BucketNode *result = hash_table_search_path(ht, key); if (result != 0) { if (value_out != 0) { *value_out = result->v.value_u64; } return 1; } return 0; } internal BucketNode * hash_table_push_u32_u32(Arena *arena, HashTable *ht, U32 key, U32 value) { U64 hash = hash_table_hasher(str8_struct(&key)); return hash_table_push(arena, ht, hash, (KeyValuePair){ .key_u32 = key, .value_u32 = value }); } internal BucketNode * hash_table_push_raw_raw(Arena *arena, HashTable *ht, void *key, void *value) { U64 hash = hash_table_hasher(str8_struct(&key)); return hash_table_push(arena, ht, hash, (KeyValuePair){ .key_raw = key, .value_raw = value }); } internal B32 hash_table_search_string_u64(HashTable *ht, String8 key, U64 *value_out) { BucketNode *result = hash_table_search_string(ht, key); if (result != 0) { if (value_out != 0) { *value_out = result->v.value_u64; } return 1; } return 0; } internal B32 hash_table_search_string_string(HashTable *ht, String8 key, String8 *value_out) { BucketNode *result = hash_table_search_string(ht, key); if (result) { if (value_out) { *value_out = result->v.value_string; } return 1; } return 0; } internal B32 hash_table_search_u32_u32(HashTable *ht, U32 key, U32 *value_out) { BucketNode *result = hash_table_search_u32(ht, key); if (result) { if (value_out) { *value_out = result->v.value_u32; } return 1; } return 0; } internal void * hash_table_search_string_raw(HashTable *ht, String8 key) { BucketNode *result = hash_table_search_string(ht, key); if (result) { return result->v.value_raw; } return 0; } internal void * hash_table_search_u64_raw(HashTable *ht, U64 key_u64) { BucketNode *n = hash_table_search_u64(ht, key_u64); return n ? n->v.value_raw : 0; } internal void * hash_table_search_path_raw(HashTable *ht, String8 path) { BucketNode *n = hash_table_search_path(ht, path); return n ? n->v.value_raw : 0; } internal void * hash_table_search_raw_raw(HashTable *ht, void *key) { BucketNode *n = hash_table_search_raw(ht, key); return n ? n->v.value_raw : 0; } internal void hash_table_purge_item(HashTable *ht, U64 hash, BucketNode *node) { U64 bucket_idx = hash % ht->cap; DLLRemove(ht->buckets[bucket_idx].first, ht->buckets[bucket_idx].last, node); SLLQueuePush(ht->free_buckets.first, ht->free_buckets.last, node); ht->count -= 1; } internal B32 hash_table_purge_u64(HashTable *ht, U64 key) { U64 hash = hash_table_hasher(str8_struct(&key)); BucketNode *n = hash_table_search_u64(ht, key); if (n) { hash_table_purge_item(ht, hash, n); return 1; } return 0; } internal B32 hash_table_purge_string(HashTable *ht, String8 key) { U64 hash = hash_table_hasher(key); BucketNode *n = hash_table_search_string(ht, key); if (n) { hash_table_purge_item(ht, hash, n); return 1; } return 0; } internal int key_value_pair_is_before_u32(void *a, void *b) { return ((KeyValuePair *)a)->key_u32 < ((KeyValuePair *)b)->key_u32; } internal int key_value_pair_is_before_u64(void *a, void *b) { return ((KeyValuePair *)a)->key_u64 < ((KeyValuePair *)b)->key_u64; } internal int key_value_pair_is_before_string_sensitive(void *a, void *b) { return str8_compar_case_sensitive(&((KeyValuePair*)a)->key_string, &((KeyValuePair*)b)->key_string) < 0; } internal U32 * keys_from_hash_table_u32(Arena *arena, HashTable *ht) { U32 *result = push_array_no_zero(arena, U32, ht->count); for (U64 bucket_idx = 0, cursor = 0; bucket_idx < ht->cap; ++bucket_idx) { for (BucketNode *n = ht->buckets[bucket_idx].first; n != 0; n = n->next) { Assert(cursor < ht->count); result[cursor++] = n->v.key_u32; } } return result; } internal U64 * keys_from_hash_table_u64(Arena *arena, HashTable *ht) { U64 *result = push_array_no_zero(arena, U64, ht->count); for (U64 bucket_idx = 0, cursor = 0; bucket_idx < ht->cap; ++bucket_idx) { for (BucketNode *n = ht->buckets[bucket_idx].first; n != 0; n = n->next) { Assert(cursor < ht->count); result[cursor++] = n->v.key_u64; } } return result; } internal String8 * keys_from_hash_table_string(Arena *arena, HashTable *ht) { String8 *result = push_array_no_zero(arena, String8, ht->count); for (U64 bucket_idx = 0, cursor = 0; bucket_idx < ht->cap; ++bucket_idx) { for (BucketNode *n = ht->buckets[bucket_idx].first; n != 0; n = n->next) { Assert(cursor < ht->count); result[cursor++] = n->v.key_string; } } return result; } internal KeyValuePair * key_value_pairs_from_hash_table(Arena *arena, HashTable *ht) { KeyValuePair *pairs = push_array_no_zero(arena, KeyValuePair, ht->count); for (U64 bucket_idx = 0, cursor = 0; bucket_idx < ht->cap; ++bucket_idx) { for (BucketNode *n = ht->buckets[bucket_idx].first; n != 0; n = n->next) { Assert(cursor < ht->count); pairs[cursor++] = n->v; } } return pairs; } internal void * keys_from_hash_table_raw(Arena *arena, HashTable *ht) { void **result = push_array(arena, void *, ht->count); for (U64 bucket_idx = 0, cursor = 0; bucket_idx < ht->cap; ++bucket_idx) { for (BucketNode *n = ht->buckets[bucket_idx].first; n != 0; n = n->next) { Assert(cursor < ht->count); result[cursor++] = n->v.key_raw; } } return result; } internal void * values_from_hash_table_raw(Arena *arena, HashTable *ht) { void **result = push_array(arena, void *, ht->count); for (U64 bucket_idx = 0, cursor = 0; bucket_idx < ht->cap; ++bucket_idx) { for (BucketNode *n = ht->buckets[bucket_idx].first; n != 0; n = n->next) { Assert(cursor < ht->count); result[cursor++] = n->v.value_raw; } } return result; } #include "third_party/radsort/radsort.h" internal void sort_key_value_pairs_as_u32(KeyValuePair *pairs, U64 count) { radsort(pairs, count, key_value_pair_is_before_u32); } internal void sort_key_value_pairs_as_u64(KeyValuePair *pairs, U64 count) { radsort(pairs, count, key_value_pair_is_before_u64); } internal void sort_key_value_pairs_as_string_sensitive(KeyValuePair *pairs, U64 count) { radsort(pairs, count, key_value_pair_is_before_string_sensitive); } internal U64Array remove_duplicates_u64_array(Arena *arena, U64Array arr) { Temp scratch = scratch_begin(&arena, 1); HashTable *ht = hash_table_init(scratch.arena, ((U64)(F64)arr.count * 0.5)); for (U64 i = 0; i < arr.count; ++i) { BucketNode *is_present = hash_table_search_u64(ht, arr.v[i]); if (!is_present) { hash_table_push_u64_raw(scratch.arena, ht, arr.v[i], 0); } } U64Array result = {0}; result.count = ht->count; result.v = keys_from_hash_table_u64(arena, ht); scratch_end(scratch); return result; } internal String8List remove_duplicates_str8_list(Arena *arena, String8List list) { Temp scratch = scratch_begin(&arena, 1); String8List result = {0}; HashTable *ht = hash_table_init(scratch.arena, list.node_count); for (String8Node *node = list.first; node != 0; node = node->next) { BucketNode *is_present = hash_table_search_string(ht, node->string); if (!is_present) { hash_table_push_string_raw(scratch.arena, ht, node->string, 0); str8_list_push(arena, &result, node->string); } } scratch_end(scratch); return result; } internal String8 ** str8_from_key_value_pairs(Arena *arena, KeyValuePair *v, U64 count) { String8 **result = push_array(arena, String8 *, count); for EachIndex(i, count) { result[i] = &v[i].value_string; } return result; } //////////////////////////////// internal U64 hash_map_hasher(String8 string) { return u64_hash_from_str8(string); } internal HashMapNode ** hash_map_search_(HashMap *hm, U64 hash, HashMapKey key, HashMapKeyMatchFunc *match_func, B32 *found_out) { HashMapNode **n = &hm->root; HashMapNode **last_tombstone = 0; *found_out = 0; for (U64 h = hash; *n != 0; h <<= 2) { if ((*n)->is_live) { if (match_func(&(*n)->v.key, &key)) { *found_out = 1; return n; } } else { last_tombstone = n; } n = &(*n)->children[h >> 62]; } if (last_tombstone != 0) { hm->tombstone_count -= 1; return last_tombstone; } return n; } internal HashMapNode * hash_map_search(HashMap *hm, U64 hash, HashMapKey key, HashMapKeyMatchFunc *match_func) { B32 found = 0; HashMapNode **n = hash_map_search_(hm, hash, key, match_func, &found); return found ? *n : 0; } internal HashMapNode * hash_map_push(Arena *arena, HashMap *hm, U64 hash, HashMapKeyValue key_value, HashMapKeyMatchFunc *match_func) { B32 found = 0; HashMapNode **n = hash_map_search_(hm, hash, key_value.key, match_func, &found); if (found) { return *n; } if (*n == 0) { *n = hm->free_list; if (hm->free_list) { SLLStackPop(hm->free_list); } else { *n = push_array(arena, HashMapNode, 1); } } (*n)->v = key_value; (*n)->is_live = 1; hm->count += 1; return *n; } internal B32 hash_map_purge_item(HashMap *hm, U64 hash, HashMapKey key, HashMapKeyMatchFunc *match_func) { B32 found = 0; HashMapNode **n = hash_map_search_(hm, hash, key, match_func, &found); if (found) { (*n)->is_live = 0; hm->count -= 1; hm->tombstone_count += 1; } return found; } internal void hash_map_purge(HashMap *hm) { Temp scratch = scratch_begin(0,0); typedef struct Stack { struct Stack *next; HashMapNode *node; U32 next_child_idx; } Stack; Stack *free_list = 0; Stack *stack = 0; if (hm->count > 0) { stack = push_array(scratch.arena, Stack, 1); stack->node = hm->root; } while (stack) { // descend while (stack->next_child_idx < ArrayCount(stack->node->children)) { HashMapNode *child = stack->node->children[stack->next_child_idx]; stack->next_child_idx += 1; if (child) { Stack *f = free_list; if (f) { SLLStackPop(free_list); } else { f = push_array(scratch.arena, Stack, 1); } f->node = child; SLLStackPush(stack, f); break; } } // ascend if (stack->next_child_idx >= ArrayCount(stack->node->children)) { SLLStackPush(hm->free_list, stack->node); SLLStackPop(stack); } } scratch_end(scratch); } //////////////////////////////// force_inline HASH_MAP_KEY_MATCH(hash_map_match_u32) { return a->key_u32 == b->key_u32; } force_inline HASH_MAP_KEY_MATCH(hash_map_match_u64) { return a->key_u64 == b->key_u64; } force_inline HASH_MAP_KEY_MATCH(hash_map_match_raw) { return a->key_raw == b->key_raw; } force_inline HASH_MAP_KEY_MATCH(hash_map_match_string) { return str8_match(a->key_string, b->key_string, 0); } force_inline HASH_MAP_KEY_MATCH(hash_map_match_path) { return str8_match(a->key_string, b->key_string, StringMatchFlag_CaseInsensitive|StringMatchFlag_SlashInsensitive); } internal U64 hash_map_hash_from_path(String8 path) { Temp scratch = scratch_begin(0, 0); String8 path_canon = path; path_canon = lower_from_str8(scratch.arena, path_canon); path_canon = path_convert_slashes(scratch.arena, path_canon, PathStyle_UnixAbsolute); U64 hash = hash_map_hasher(path_canon); scratch_end(scratch); return hash; } //////////////////////////////// internal HashMapNode * hash_map_push_string_string(Arena *arena, HashMap *hm, String8 key, String8 value) { key = push_str8_copy(arena, key); value = push_str8_copy(arena, value); return hash_map_push(arena, hm, hash_map_hasher(key), (HashMapKeyValue){ .key = { .key_string = key }, .value = { .value_string = value } }, hash_map_match_string); } internal HashMapNode * hash_map_push_string_raw(Arena *arena, HashMap *hm, String8 key, void *value) { key = push_str8_copy(arena, key); return hash_map_push(arena, hm, hash_map_hasher(key), (HashMapKeyValue){ .key = { .key_string = key }, .value = { .value_raw = value } }, hash_map_match_string); } internal HashMapNode * hash_map_push_string_u64(Arena *arena, HashMap *hm, String8 key, U64 value) { key = push_str8_copy(arena, key); return hash_map_push(arena, hm, hash_map_hasher(key), (HashMapKeyValue){ .key = { .key_string = key }, .value = { .value_u64 = value } }, hash_map_match_string); } internal HashMapNode * hash_map_push_u32_raw(Arena *arena, HashMap *hm, U32 key, void *value) { return hash_map_push(arena, hm, hash_map_hasher(str8_struct(&key)), (HashMapKeyValue){ .key = { .key_u32 = key }, .value = { .value_raw = value } }, hash_map_match_u32); } internal HashMapNode * hash_map_push_u32_string(Arena *arena, HashMap *hm, U32 key, String8 value) { return hash_map_push(arena, hm, hash_map_hasher(str8_struct(&key)), (HashMapKeyValue){ .key = { .key_u32 = key }, .value = { .value_string = value } }, hash_map_match_u32); } internal HashMapNode * hash_map_push_u64_raw(Arena *arena, HashMap *hm, U64 key, void *value) { return hash_map_push(arena, hm, hash_map_hasher(str8_struct(&key)), (HashMapKeyValue){ .key = { .key_u64 = key }, .value = { .value_raw = value } }, hash_map_match_u64); } internal HashMapNode * hash_map_push_u64_string(Arena *arena, HashMap *hm, U64 key, String8 value) { return hash_map_push(arena, hm, hash_map_hasher(str8_struct(&key)), (HashMapKeyValue){ .key = { .key_u64 = key }, .value = { .value_string = value } }, hash_map_match_u64); } internal HashMapNode * hash_map_push_u64_u64(Arena *arena, HashMap *hm, U64 key, U64 value) { return hash_map_push(arena, hm, hash_map_hasher(str8_struct(&key)), (HashMapKeyValue){ .key = { .key_u64 = key }, .value = { .value_u64 = value } }, hash_map_match_u64); } internal HashMapNode * hash_map_push_raw_raw(Arena *arena, HashMap *hm, void *key, void *value) { return hash_map_push(arena, hm, hash_map_hasher(str8_struct(&key)), (HashMapKeyValue){ .key = { .key_raw = key }, .value = { .value_raw = value } }, hash_map_match_raw); } internal HashMapNode * hash_map_push_raw_u64(Arena *arena, HashMap *hm, void *key, U64 value) { return hash_map_push(arena, hm, hash_map_hasher(str8_struct(&key)), (HashMapKeyValue){ .key = { .key_raw = key }, .value = { .value_u64 = value } }, hash_map_match_u64); } internal HashMapNode * hash_map_push_path_u64(Arena *arena, HashMap *hm, String8 path, U64 value) { path = push_str8_copy(arena, path); return hash_map_push(arena, hm, hash_map_hash_from_path(path), (HashMapKeyValue){ .key = { .key_string = path }, .value = { .value_u64 = value } }, hash_map_match_path); } internal HashMapNode * hash_map_push_path_string(Arena *arena, HashMap *hm, String8 path, String8 value) { path = push_str8_copy(arena, path); value = push_str8_copy(arena, value); return hash_map_push(arena, hm, hash_map_hash_from_path(path), (HashMapKeyValue){ .key = { .key_string = path }, .value = { .value_string = value } }, hash_map_match_path); } internal HashMapNode * hash_map_push_path_raw(Arena *arena, HashMap *hm, String8 path, void *value) { path = push_str8_copy(arena, path); return hash_map_push(arena, hm, hash_map_hash_from_path(path), (HashMapKeyValue){ .key = { .key_string = path }, .value = { .value_raw = value } }, hash_map_match_path); } //////////////////////////////// internal void * hash_map_search_stringf_raw(HashMap *hm, char *fmt, ...) { Temp scratch = scratch_begin(0,0); va_list args; va_start(args, fmt); String8 string = push_str8fv(scratch.arena, fmt, args); void *raw = hash_map_search_string_raw(hm, string); va_end(args); scratch_end(scratch); return raw; } internal void * hash_map_search_string_raw(HashMap *hm, String8 key) { HashMapNode *n = hash_map_search(hm, hash_map_hasher(key), (HashMapKey){ .key_string = key }, hash_map_match_string); return n ? n->v.value.value_raw : 0; } internal String8 * hash_map_search_string_string(HashMap *hm, String8 key) { HashMapNode *n = hash_map_search(hm, hash_map_hasher(key), (HashMapKey){ .key_string = key }, hash_map_match_string); return n ? &n->v.value.value_string : 0; } internal U32 * hash_map_search_string_u32(HashMap *hm, String8 key) { HashMapNode *n = hash_map_search(hm, hash_map_hasher(key), (HashMapKey){ .key_string = key }, hash_map_match_string); return n ? &n->v.value.value_u32 : 0; } internal U64 * hash_map_search_string_u64(HashMap *hm, String8 key) { HashMapNode *n = hash_map_search(hm, hash_map_hasher(key), (HashMapKey){ .key_string = key }, hash_map_match_string); return n ? &n->v.value.value_u64 : 0; } internal U64 * hash_map_search_path_u64(HashMap *hm, String8 key) { HashMapNode *n = hash_map_search(hm, hash_map_hash_from_path(key), (HashMapKey){ .key_string = key }, hash_map_match_path); return n ? &n->v.value.value_u64 : 0; } internal String8 * hash_map_search_path_string(HashMap *hm, String8 key) { HashMapNode *n = hash_map_search(hm, hash_map_hash_from_path(key), (HashMapKey){ .key_string = key }, hash_map_match_path); return n ? &n->v.value.value_string : 0; } internal void * hash_map_search_path_raw(HashMap *hm, String8 key) { HashMapNode *n = hash_map_search(hm, hash_map_hash_from_path(key), (HashMapKey){ .key_string = key }, hash_map_match_path); return n ? n->v.value.value_raw : 0; } internal void * hash_map_search_u64_raw(HashMap *hm, U64 key) { HashMapNode *n = hash_map_search(hm, hash_map_hasher(str8_struct(&key)), (HashMapKey){ .key_u64 = key }, hash_map_match_u64); return n ? n->v.value.value_raw : 0; } internal U64 * hash_map_search_u64_u64(HashMap *hm, U64 key) { HashMapNode *n = hash_map_search(hm, hash_map_hasher(str8_struct(&key)), (HashMapKey){ .key_u64 = key }, hash_map_match_u64); return n ? &n->v.value.value_u64 : 0; } internal String8 * hash_map_search_u64_string(HashMap *hm, U64 key) { HashMapNode *n = hash_map_search(hm, hash_map_hasher(str8_struct(&key)), (HashMapKey){ .key_u64 = key }, hash_map_match_u64); return n ? &n->v.value.value_string : 0; } internal void * hash_map_search_raw_raw(HashMap *hm, void *key) { HashMapNode *n = hash_map_search(hm, hash_map_hasher(str8_struct(&key)), (HashMapKey){ .key_raw = key }, hash_map_match_raw); return n ? n->v.value.value_raw : 0; } internal U64 * hash_map_search_raw_u64(HashMap *hm, void *key) { HashMapNode *n = hash_map_search(hm, hash_map_hasher(str8_struct(&key)), (HashMapKey){ .key_raw = key }, hash_map_match_raw); return n ? &n->v.value.value_u64 : 0; } //////////////////////////////// internal B32 hash_map_purge_u32(HashMap *hm, U32 key) { return hash_map_purge_item(hm, hash_map_hasher(str8_struct(&key)), (HashMapKey){ .key_u32 = key }, hash_map_match_u32); } internal B32 hash_map_purge_u64(HashMap *hm, U64 key) { return hash_map_purge_item(hm, hash_map_hasher(str8_struct(&key)), (HashMapKey){ .key_u64 = key }, hash_map_match_u64); } internal B32 hash_map_purge_string(HashMap *hm, String8 key) { return hash_map_purge_item(hm, hash_map_hasher(key), (HashMapKey){ .key_string = key }, hash_map_match_string); } //////////////////////////////// #define HASH_MAP_EXTRACT_FUNC(name) void name(HashMapKeyValue *kv, void *buffer) typedef HASH_MAP_EXTRACT_FUNC(HashMapExtractFunc); typedef struct { void *keys; void *values; } HashMapExtract; internal HashMapExtract hash_map_extract(Arena *arena, HashMap *hm, HashMapExtractFunc *key_func, U64 key_size, HashMapExtractFunc *value_func, U64 value_size) { Temp scratch = scratch_begin(&arena, 1); U64 key_offset = 0; U64 value_offset = 0; U8 *key_buffer = 0; U8 *value_buffer = 0; if (key_func && key_size) { key_buffer = push_array_no_zero(arena, U8, key_size * hm->count); } if (value_func && value_size) { value_buffer = push_array_no_zero(arena, U8, value_size * hm->count); } typedef struct Stack { struct Stack *next; HashMapNode *node; U32 next_child_idx; } Stack; Stack *free_list = 0; Stack *stack = 0; if (hm->count > 0) { stack = push_array(scratch.arena, Stack, 1); stack->node = hm->root; } while (stack) { // descend while (stack->next_child_idx < ArrayCount(stack->node->children)) { HashMapNode *child = stack->node->children[stack->next_child_idx]; stack->next_child_idx += 1; if (child) { Stack *f = free_list; if (f) { SLLStackPop(free_list); } else { f = push_array(scratch.arena, Stack, 1); } f->node = child; SLLStackPush(stack, f); break; } } // ascend if (stack->next_child_idx >= ArrayCount(stack->node->children)) { if (stack->node->is_live) { if (key_func) { key_func(&stack->node->v, key_buffer + key_offset); key_offset += key_size; } if (value_func) { value_func(&stack->node->v, value_buffer + value_offset); value_offset += value_size; } } SLLStackPop(stack); } } scratch_end(scratch); return (HashMapExtract){ .keys = key_buffer, .values = value_buffer }; } // { keys, value } force_inline HASH_MAP_EXTRACT_FUNC(hash_map_extract_key_value) { MemoryCopy(buffer, kv, sizeof(*kv)); } internal HashMapKeyValue * key_value_from_hash_map ( Arena *arena, HashMap *hm) { return hash_map_extract(arena, hm, hash_map_extract_key_value, sizeof(HashMapKeyValue), 0, 0).keys; } // keys force_inline HASH_MAP_EXTRACT_FUNC(hash_map_extract_key_u32) { MemoryCopy(buffer, &kv->key.key_u32, sizeof(kv->key.key_u32)); } force_inline HASH_MAP_EXTRACT_FUNC(hash_map_extract_key_u64) { MemoryCopy(buffer, &kv->key.key_u64, sizeof(kv->key.key_u64)); } force_inline HASH_MAP_EXTRACT_FUNC(hash_map_extract_key_string) { MemoryCopy(buffer, &kv->key.key_string, sizeof(kv->key.key_string)); } internal U32 * keys_from_hash_map_u32 ( Arena *arena, HashMap *hm) { return hash_map_extract(arena, hm, hash_map_extract_key_u32, sizeof(U32), 0, 0).keys; } internal U64 * keys_from_hash_map_u64 ( Arena *arena, HashMap *hm) { return hash_map_extract(arena, hm, hash_map_extract_key_u64, sizeof(U64), 0, 0).keys; } internal String8 * keys_from_hash_map_string( Arena *arena, HashMap *hm) { return hash_map_extract(arena, hm, hash_map_extract_key_string, sizeof(String8), 0, 0).keys; } internal void * keys_from_hash_map_raw ( Arena *arena, HashMap *hm) { return hash_map_extract(arena, hm, hash_map_extract_key_string, sizeof(void *), 0, 0).keys; } // values force_inline HASH_MAP_EXTRACT_FUNC(hash_map_extract_value_u64) { MemoryCopy(buffer, &kv->value.value_u64, sizeof(kv->value.value_u64)); } force_inline HASH_MAP_EXTRACT_FUNC(hash_map_extract_value_raw) { MemoryCopy(buffer, &kv->value.value_raw, sizeof(kv->value.value_raw)); } internal U64 * values_from_hash_map_u64(Arena *arena, HashMap *hm) { return hash_map_extract(arena, hm, 0, 0, hash_map_extract_value_u64, sizeof(U64)).values; } internal void * values_from_hash_map_raw(Arena *arena, HashMap *hm) {return hash_map_extract(arena, hm, 0, 0, hash_map_extract_value_raw, sizeof(void *)).values; } //////////////////////////////// force_inline int hash_map_key_is_before_u32(void *a, void *b) { return ((HashMapKeyValue*)a)->key.key_u32 < ((HashMapKeyValue*)b)->key.key_u32; } force_inline int hash_map_key_is_before_u64(void *a, void *b) { return ((HashMapKeyValue*)a)->key.key_u64 < ((HashMapKeyValue*)b)->key.key_u64; } force_inline int hash_map_key_is_before_string(void *a, void *b) { return str8_is_before_case_sensitive(a, b); } internal void sort_hash_map_key_value_u32(HashMapKeyValue *pairs, U64 count) { radsort(pairs, count, hash_map_key_is_before_u32); } internal void sort_hash_map_key_value_u64(HashMapKeyValue *pairs, U64 count) { radsort(pairs, count, hash_map_key_is_before_u64); } internal void sort_hash_map_key_value_string(HashMapKeyValue *pairs, U64 count) { radsort(pairs, count, hash_map_key_is_before_string); }