mirror of
https://github.com/odin-lang/Odin.git
synced 2026-04-17 20:12:38 +00:00
Make doc writer use the old "Ordered Insertion" based PtrMap
This commit is contained in:
gingerBill
438
src/ptr_map.cpp
438
src/ptr_map.cpp
@@ -9,12 +9,6 @@ enum {
|
||||
};
|
||||
|
||||
|
||||
struct MapFindResult {
|
||||
MapIndex hash_index;
|
||||
MapIndex entry_prev;
|
||||
MapIndex entry_index;
|
||||
};
|
||||
|
||||
enum : MapIndex { MAP_SENTINEL = ~(MapIndex)0 };
|
||||
static void *const MAP_TOMBSTONE = (void *)~(uintptr)0;
|
||||
|
||||
@@ -433,3 +427,435 @@ gb_internal PtrMapIterator<K, V> const begin(PtrMap<K, V> const &m) noexcept {
|
||||
}
|
||||
return PtrMapIterator<K, V>{&m, index};
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
struct MapFindResult {
|
||||
MapIndex hash_index;
|
||||
MapIndex entry_prev;
|
||||
MapIndex entry_index;
|
||||
};
|
||||
|
||||
template <typename K, typename V>
|
||||
struct OrderedInsertPtrMapEntry {
|
||||
static_assert(sizeof(K) == sizeof(void *), "Key size must be pointer size");
|
||||
|
||||
K key;
|
||||
V value;
|
||||
MapIndex next;
|
||||
};
|
||||
|
||||
template <typename K, typename V>
|
||||
struct OrderedInsertPtrMap {
|
||||
MapIndex *hashes;
|
||||
usize hashes_count;
|
||||
OrderedInsertPtrMapEntry<K, V> *entries;
|
||||
u32 count;
|
||||
u32 entries_capacity;
|
||||
};
|
||||
|
||||
|
||||
template <typename K, typename V> gb_internal void map_destroy (OrderedInsertPtrMap<K, V> *h);
|
||||
template <typename K, typename V> gb_internal V * map_get (OrderedInsertPtrMap<K, V> *h, K key);
|
||||
template <typename K, typename V> gb_internal void map_set (OrderedInsertPtrMap<K, V> *h, K key, V const &value);
|
||||
template <typename K, typename V> gb_internal bool map_set_if_not_previously_exists(OrderedInsertPtrMap<K, V> *h, K key, V const &value); // returns true if it previously existed
|
||||
template <typename K, typename V> gb_internal void map_remove (OrderedInsertPtrMap<K, V> *h, K key);
|
||||
template <typename K, typename V> gb_internal void map_clear (OrderedInsertPtrMap<K, V> *h);
|
||||
template <typename K, typename V> gb_internal void map_grow (OrderedInsertPtrMap<K, V> *h);
|
||||
template <typename K, typename V> gb_internal void map_rehash (OrderedInsertPtrMap<K, V> *h, isize new_count);
|
||||
template <typename K, typename V> gb_internal void map_reserve (OrderedInsertPtrMap<K, V> *h, isize cap);
|
||||
|
||||
// Mutlivalued map procedure
|
||||
template <typename K, typename V> gb_internal OrderedInsertPtrMapEntry<K, V> * multi_map_find_first(OrderedInsertPtrMap<K, V> *h, K key);
|
||||
template <typename K, typename V> gb_internal OrderedInsertPtrMapEntry<K, V> * multi_map_find_next (OrderedInsertPtrMap<K, V> *h, OrderedInsertPtrMapEntry<K, V> *e);
|
||||
|
||||
template <typename K, typename V> gb_internal isize multi_map_count (OrderedInsertPtrMap<K, V> *h, K key);
|
||||
template <typename K, typename V> gb_internal void multi_map_get_all (OrderedInsertPtrMap<K, V> *h, K key, V *items);
|
||||
template <typename K, typename V> gb_internal void multi_map_insert (OrderedInsertPtrMap<K, V> *h, K key, V const &value);
|
||||
template <typename K, typename V> gb_internal void multi_map_remove (OrderedInsertPtrMap<K, V> *h, K key, OrderedInsertPtrMapEntry<K, V> *e);
|
||||
template <typename K, typename V> gb_internal void multi_map_remove_all(OrderedInsertPtrMap<K, V> *h, K key);
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal gb_inline void map_init(OrderedInsertPtrMap<K, V> *h, isize capacity) {
|
||||
capacity = next_pow2_isize(capacity);
|
||||
map_reserve(h, capacity);
|
||||
}
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal gb_inline void map_destroy(OrderedInsertPtrMap<K, V> *h) {
|
||||
gbAllocator a = map_allocator();
|
||||
gb_free(a, h->hashes);
|
||||
gb_free(a, h->entries);
|
||||
}
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal void map__resize_hashes(OrderedInsertPtrMap<K, V> *h, usize count) {
|
||||
h->hashes_count = cast(u32)resize_array_raw(&h->hashes, map_allocator(), h->hashes_count, count, MAP_CACHE_LINE_SIZE);
|
||||
}
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal void map__reserve_entries(OrderedInsertPtrMap<K, V> *h, usize capacity) {
|
||||
h->entries_capacity = cast(u32)resize_array_raw(&h->entries, map_allocator(), h->entries_capacity, capacity, MAP_CACHE_LINE_SIZE);
|
||||
}
|
||||
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal MapIndex map__add_entry(OrderedInsertPtrMap<K, V> *h, K key) {
|
||||
OrderedInsertPtrMapEntry<K, V> e = {};
|
||||
e.key = key;
|
||||
e.next = MAP_SENTINEL;
|
||||
if (h->count+1 >= h->entries_capacity) {
|
||||
map__reserve_entries(h, gb_max(h->entries_capacity*2, 4));
|
||||
}
|
||||
h->entries[h->count++] = e;
|
||||
return cast(MapIndex)(h->count-1);
|
||||
}
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal MapFindResult map__find(OrderedInsertPtrMap<K, V> *h, K key) {
|
||||
MapFindResult fr = {MAP_SENTINEL, MAP_SENTINEL, MAP_SENTINEL};
|
||||
if (h->hashes_count == 0) {
|
||||
return fr;
|
||||
}
|
||||
u32 hash = ptr_map_hash_key(key);
|
||||
fr.hash_index = cast(MapIndex)(hash & (h->hashes_count-1));
|
||||
fr.entry_index = h->hashes[fr.hash_index];
|
||||
while (fr.entry_index != MAP_SENTINEL) {
|
||||
auto *entry = &h->entries[fr.entry_index];
|
||||
if (entry->key == key) {
|
||||
return fr;
|
||||
}
|
||||
fr.entry_prev = fr.entry_index;
|
||||
fr.entry_index = entry->next;
|
||||
}
|
||||
return fr;
|
||||
}
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal MapFindResult map__find_from_entry(OrderedInsertPtrMap<K, V> *h, OrderedInsertPtrMapEntry<K, V> *e) {
|
||||
MapFindResult fr = {MAP_SENTINEL, MAP_SENTINEL, MAP_SENTINEL};
|
||||
if (h->hashes_count == 0) {
|
||||
return fr;
|
||||
}
|
||||
u32 hash = ptr_map_hash_key(e->key);
|
||||
fr.hash_index = cast(MapIndex)(hash & (h->hashes_count-1));
|
||||
fr.entry_index = h->hashes[fr.hash_index];
|
||||
while (fr.entry_index != MAP_SENTINEL) {
|
||||
if (&h->entries[fr.entry_index] == e) {
|
||||
return fr;
|
||||
}
|
||||
fr.entry_prev = fr.entry_index;
|
||||
fr.entry_index = h->entries[fr.entry_index].next;
|
||||
}
|
||||
return fr;
|
||||
}
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal b32 map__full(OrderedInsertPtrMap<K, V> *h) {
|
||||
return 0.75f * h->hashes_count <= h->count;
|
||||
}
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal gb_inline void map_grow(OrderedInsertPtrMap<K, V> *h) {
|
||||
isize new_count = gb_max(h->hashes_count<<1, 16);
|
||||
map_rehash(h, new_count);
|
||||
}
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal void map_reset_entries(OrderedInsertPtrMap<K, V> *h) {
|
||||
for (usize i = 0; i < h->hashes_count; i++) {
|
||||
h->hashes[i] = MAP_SENTINEL;
|
||||
}
|
||||
for (usize i = 0; i < h->count; i++) {
|
||||
MapFindResult fr;
|
||||
OrderedInsertPtrMapEntry<K, V> *e = &h->entries[i];
|
||||
e->next = MAP_SENTINEL;
|
||||
fr = map__find_from_entry(h, e);
|
||||
if (fr.entry_prev == MAP_SENTINEL) {
|
||||
h->hashes[fr.hash_index] = cast(MapIndex)i;
|
||||
} else {
|
||||
h->entries[fr.entry_prev].next = cast(MapIndex)i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal void map_reserve(OrderedInsertPtrMap<K, V> *h, isize cap) {
|
||||
if (h->count*2 < h->hashes_count) {
|
||||
return;
|
||||
}
|
||||
map__reserve_entries(h, cap);
|
||||
map__resize_hashes(h, cap*2);
|
||||
map_reset_entries(h);
|
||||
}
|
||||
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal void map_rehash(OrderedInsertPtrMap<K, V> *h, isize new_count) {
|
||||
map_reserve(h, new_count);
|
||||
}
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal V *map_get(OrderedInsertPtrMap<K, V> *h, K key) {
|
||||
MapIndex hash_index = MAP_SENTINEL;
|
||||
MapIndex entry_prev = MAP_SENTINEL;
|
||||
MapIndex entry_index = MAP_SENTINEL;
|
||||
if (h->hashes_count != 0) {
|
||||
u32 hash = ptr_map_hash_key(key);
|
||||
hash_index = cast(MapIndex)(hash & (h->hashes_count-1));
|
||||
entry_index = h->hashes[hash_index];
|
||||
while (entry_index != MAP_SENTINEL) {
|
||||
auto *entry = &h->entries[entry_index];
|
||||
if (entry->key == key) {
|
||||
return &entry->value;
|
||||
}
|
||||
entry_prev = entry_index;
|
||||
entry_index = entry->next;
|
||||
}
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
template <typename K, typename V>
|
||||
gb_internal V *map_try_get(OrderedInsertPtrMap<K, V> *h, K key, MapFindResult *fr_) {
|
||||
MapFindResult fr = {MAP_SENTINEL, MAP_SENTINEL, MAP_SENTINEL};
|
||||
if (h->hashes_count != 0) {
|
||||
u32 hash = ptr_map_hash_key(key);
|
||||
fr.hash_index = cast(MapIndex)(hash & (h->hashes_count-1));
|
||||
fr.entry_index = h->hashes[fr.hash_index];
|
||||
while (fr.entry_index != MAP_SENTINEL) {
|
||||
auto *entry = &h->entries[fr.entry_index];
|
||||
if (entry->key == key) {
|
||||
return &entry->value;
|
||||
}
|
||||
fr.entry_prev = fr.entry_index;
|
||||
fr.entry_index = entry->next;
|
||||
}
|
||||
}
|
||||
if (h->hashes_count == 0 || map__full(h)) {
|
||||
map_grow(h);
|
||||
}
|
||||
if (fr_) *fr_ = fr;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal void map_set_internal_from_try_get(OrderedInsertPtrMap<K, V> *h, K key, V const &value, MapFindResult const &fr) {
|
||||
MapIndex index = map__add_entry(h, key);
|
||||
if (fr.entry_prev != MAP_SENTINEL) {
|
||||
h->entries[fr.entry_prev].next = index;
|
||||
} else {
|
||||
h->hashes[fr.hash_index] = index;
|
||||
}
|
||||
h->entries[index].value = value;
|
||||
}
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal V &map_must_get(OrderedInsertPtrMap<K, V> *h, K key) {
|
||||
V *ptr = map_get(h, key);
|
||||
GB_ASSERT(ptr != nullptr);
|
||||
return *ptr;
|
||||
}
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal void map_set(OrderedInsertPtrMap<K, V> *h, K key, V const &value) {
|
||||
MapIndex index;
|
||||
MapFindResult fr;
|
||||
if (h->hashes_count == 0) {
|
||||
map_grow(h);
|
||||
}
|
||||
fr = map__find(h, key);
|
||||
if (fr.entry_index != MAP_SENTINEL) {
|
||||
index = fr.entry_index;
|
||||
} else {
|
||||
index = map__add_entry(h, key);
|
||||
if (fr.entry_prev != MAP_SENTINEL) {
|
||||
h->entries[fr.entry_prev].next = index;
|
||||
} else {
|
||||
h->hashes[fr.hash_index] = index;
|
||||
}
|
||||
}
|
||||
h->entries[index].value = value;
|
||||
|
||||
if (map__full(h)) {
|
||||
map_grow(h);
|
||||
}
|
||||
}
|
||||
|
||||
// returns true if it previously existed
|
||||
template <typename K, typename V>
|
||||
gb_internal bool map_set_if_not_previously_exists(OrderedInsertPtrMap<K, V> *h, K key, V const &value) {
|
||||
MapIndex index;
|
||||
MapFindResult fr;
|
||||
if (h->hashes_count == 0) {
|
||||
map_grow(h);
|
||||
}
|
||||
fr = map__find(h, key);
|
||||
if (fr.entry_index != MAP_SENTINEL) {
|
||||
return true;
|
||||
} else {
|
||||
index = map__add_entry(h, key);
|
||||
if (fr.entry_prev != MAP_SENTINEL) {
|
||||
h->entries[fr.entry_prev].next = index;
|
||||
} else {
|
||||
h->hashes[fr.hash_index] = index;
|
||||
}
|
||||
}
|
||||
h->entries[index].value = value;
|
||||
|
||||
if (map__full(h)) {
|
||||
map_grow(h);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal void map__erase(OrderedInsertPtrMap<K, V> *h, MapFindResult const &fr) {
|
||||
MapFindResult last;
|
||||
if (fr.entry_prev == MAP_SENTINEL) {
|
||||
h->hashes[fr.hash_index] = h->entries[fr.entry_index].next;
|
||||
} else {
|
||||
h->entries[fr.entry_prev].next = h->entries[fr.entry_index].next;
|
||||
}
|
||||
if (fr.entry_index == h->count-1) {
|
||||
h->count--;
|
||||
return;
|
||||
}
|
||||
h->entries[fr.entry_index] = h->entries[h->count-1];
|
||||
h->count--;
|
||||
|
||||
last = map__find(h, h->entries[fr.entry_index].key);
|
||||
if (last.entry_prev != MAP_SENTINEL) {
|
||||
h->entries[last.entry_prev].next = fr.entry_index;
|
||||
} else {
|
||||
h->hashes[last.hash_index] = fr.entry_index;
|
||||
}
|
||||
}
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal void map_remove(OrderedInsertPtrMap<K, V> *h, K key) {
|
||||
MapFindResult fr = map__find(h, key);
|
||||
if (fr.entry_index != MAP_SENTINEL) {
|
||||
map__erase(h, fr);
|
||||
}
|
||||
}
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal gb_inline void map_clear(OrderedInsertPtrMap<K, V> *h) {
|
||||
h->count = 0;
|
||||
for (usize i = 0; i < h->hashes_count; i++) {
|
||||
h->hashes[i] = MAP_SENTINEL;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal OrderedInsertPtrMapEntry<K, V> *multi_map_find_first(OrderedInsertPtrMap<K, V> *h, K key) {
|
||||
MapIndex i = map__find(h, key).entry_index;
|
||||
if (i == MAP_SENTINEL) {
|
||||
return nullptr;
|
||||
}
|
||||
return &h->entries[i];
|
||||
}
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal OrderedInsertPtrMapEntry<K, V> *multi_map_find_next(OrderedInsertPtrMap<K, V> *h, OrderedInsertPtrMapEntry<K, V> *e) {
|
||||
MapIndex i = e->next;
|
||||
while (i != MAP_SENTINEL) {
|
||||
if (h->entries[i].key == e->key) {
|
||||
return &h->entries[i];
|
||||
}
|
||||
i = h->entries[i].next;
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal isize multi_map_count(OrderedInsertPtrMap<K, V> *h, K key) {
|
||||
isize count = 0;
|
||||
OrderedInsertPtrMapEntry<K, V> *e = multi_map_find_first(h, key);
|
||||
while (e != nullptr) {
|
||||
count++;
|
||||
e = multi_map_find_next(h, e);
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal void multi_map_get_all(OrderedInsertPtrMap<K, V> *h, K key, V *items) {
|
||||
usize i = 0;
|
||||
OrderedInsertPtrMapEntry<K, V> *e = multi_map_find_first(h, key);
|
||||
while (e != nullptr) {
|
||||
items[i++] = e->value;
|
||||
e = multi_map_find_next(h, e);
|
||||
}
|
||||
}
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal void multi_map_insert(OrderedInsertPtrMap<K, V> *h, K key, V const &value) {
|
||||
MapFindResult fr;
|
||||
MapIndex i;
|
||||
if (h->hashes_count == 0) {
|
||||
map_grow(h);
|
||||
}
|
||||
// Make
|
||||
fr = map__find(h, key);
|
||||
i = map__add_entry(h, key);
|
||||
if (fr.entry_prev == MAP_SENTINEL) {
|
||||
h->hashes[fr.hash_index] = i;
|
||||
} else {
|
||||
h->entries[fr.entry_prev].next = i;
|
||||
}
|
||||
h->entries[i].next = fr.entry_index;
|
||||
h->entries[i].value = value;
|
||||
// Grow if needed
|
||||
if (map__full(h)) {
|
||||
map_grow(h);
|
||||
}
|
||||
}
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal void multi_map_remove(OrderedInsertPtrMap<K, V> *h, K key, OrderedInsertPtrMapEntry<K, V> *e) {
|
||||
MapFindResult fr = map__find_from_entry(h, e);
|
||||
if (fr.entry_index != MAP_SENTINEL) {
|
||||
map__erase(h, fr);
|
||||
}
|
||||
}
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal void multi_map_remove_all(OrderedInsertPtrMap<K, V> *h, K key) {
|
||||
while (map_get(h, key) != nullptr) {
|
||||
map_remove(h, key);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal OrderedInsertPtrMapEntry<K, V> *begin(OrderedInsertPtrMap<K, V> &m) {
|
||||
return m.entries;
|
||||
}
|
||||
template <typename K, typename V>
|
||||
gb_internal OrderedInsertPtrMapEntry<K, V> const *begin(OrderedInsertPtrMap<K, V> const &m) {
|
||||
return m.entries;
|
||||
}
|
||||
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal OrderedInsertPtrMapEntry<K, V> *end(OrderedInsertPtrMap<K, V> &m) {
|
||||
return m.entries + m.count;
|
||||
}
|
||||
|
||||
template <typename K, typename V>
|
||||
gb_internal OrderedInsertPtrMapEntry<K, V> const *end(OrderedInsertPtrMap<K, V> const &m) {
|
||||
return m.entries + m.count;
|
||||
}
|
||||
Reference in New Issue
Block a user