core/container/handle_map package | Odin Programming Language

Handle-based map using either fixed-length arrays, or exponential arrays from "core:container/xar". Example: import hm "core:container/handle_map" Handle :: hm.Handle32 Entity :: struct { handle: Handle, pos: [2]f32, } { // static map entities: hm.Static_Handle_Map(1024, Entity, Handle) h1 := hm.add(&entities, Entity{pos = {1, 4}}) h2 := hm.add(&entities, Entity{pos = {9, 16}}) if e, ok := hm.get(&entities, h2); ok { e.pos.x += 32 } hm.remove(&entities, h1) h3 := hm.add(&entities, Entity{pos = {6, 7}}) assert(hm.is_valid(entities, h3)) it := hm.iterator_make(&entities) for e, h in hm.iterate(&it) { assert(hm.is_valid(entities, h)) e.pos += {1, 2} } } { // dynamic map entities: hm.Dynamic_Handle_Map(Entity, Handle) hm.dynamic_init(&entities, context.allocator) defer hm.dynamic_destroy(&entities) h1 := hm.add(&entities, Entity{pos = {1, 4}}) h2 := hm.add(&entities, Entity{pos = {9, 16}}) if e, ok := hm.get(&entities, h2); ok { e.pos.x += 32 } hm.remove(&entities, h1) h3 := hm.add(&entities, Entity{pos = {6, 7}}) assert(hm.is_valid(entities, h3)) it := hm.iterator_make(&entities) for e, h in hm.iterate(&it) { assert(hm.is_valid(entities, h)) e.pos += {1, 2} } }

Collection Info

Collection: core
Path: container/handle_map
Entries: 36

Source Files

Types

7

Dynamic_Handle_Map #

Dynamic_Handle_Map :: Dynamic_Handle_Map

Dynamic_Handle_Map_Iterator #

Dynamic_Handle_Map_Iterator :: Dynamic_Handle_Map_Iterator

An iterator for a handle map.

Handle16 #

Handle16 :: Handle16

Default 16-bit Handle type which can be used for handle maps which only need a maximum of 254 (1<<8 - 2) items

Handle32 #

Handle32 :: Handle32

Default 32-bit Handle type which can be used for handle maps which only need a maximum of 65534 (1<<16 - 2) items

Handle64 #

Handle64 :: Handle64

Default 64-bit Handle type which can be used for handle maps which only need a maximum of 4294967294 (1<<32 - 2) items

Static_Handle_Map #

Static_Handle_Map :: Static_Handle_Map

Static_Handle_Map_Iterator #

Static_Handle_Map_Iterator :: Static_Handle_Map_Iterator

An iterator for a handle map.

Procedures

20

dynamic_add #

@(require_results)

dynamic_add :: proc(m: ^$D/Dynamic_Handle_Map($T, $Handle_Type), item: $T, loc := #caller_location) -> (handle: $$deferred_return, err: Allocator_Error) #optional_ok {…}

dynamic_cap #

@(require_results)

dynamic_cap :: proc "contextless" (m: $D/Dynamic_Handle_Map($T, $Handle_Type)) -> uint {…}

dynamic_clear #

dynamic_clear :: proc "contextless" (m: ^$D/Dynamic_Handle_Map($T, $Handle_Type)) {…}

dynamic_destroy #

dynamic_destroy :: proc(m: ^$D/Dynamic_Handle_Map($T, $Handle_Type)) {…}

dynamic_get #

@(require_results)

dynamic_get :: proc "contextless" (m: ^$D/Dynamic_Handle_Map($T, $Handle_Type), h: $Handle_Type) -> ($$deferred_return, bool) #optional_ok {…}

dynamic_init #

dynamic_init :: proc(m: ^$D/Dynamic_Handle_Map($T, $Handle_Type), allocator: Allocator) {…}

dynamic_is_valid #

@(require_results)

dynamic_is_valid :: proc "contextless" (m: ^$D/Dynamic_Handle_Map($T, $Handle_Type), h: $Handle_Type) -> bool {…}

dynamic_iterate #

@(require_results)

dynamic_iterate :: proc "contextless" (it: ^$DHI/Dynamic_Handle_Map_Iterator($D)) -> (val: $$deferred_return, h: $$deferred_return, ok: bool) {…}

Iterate over a handle map. It will skip over unused item slots (e.g. handle.idx == 0). Usage: it := hm.dynamic_iterator_make(&the_dynamic_handle_map) for item, handle in hm.iterate(&it) { ... }

dynamic_iterator_make #

@(require_results)

dynamic_iterator_make :: proc "contextless" (m: ^$D/Dynamic_Handle_Map($T, $Handle_Type)) -> $$deferred_return {…}

Makes an iterator from a handle map.

dynamic_len #

@(require_results)

dynamic_len :: proc "contextless" (m: $D/Dynamic_Handle_Map($T, $Handle_Type)) -> uint {…}

Returns the number of possibly valid items in the handle map.

dynamic_remove #

dynamic_remove :: proc(m: ^$D/Dynamic_Handle_Map($T, $Handle_Type), h: $Handle_Type, loc := #caller_location) -> (found: bool, err: Allocator_Error) {…}

static_add #

@(require_results)

static_add :: proc "contextless" (m: ^$H/Static_Handle_Map($N, $T, $Handle_Type), item: $T) -> (handle: $$deferred_return, ok: bool) #optional_ok {…}

`add` a value of type `T` to the handle map. This will return a pointer to the item and an optional boolean to check for validity.

static_cap #

@(require_results)

static_cap :: proc "contextless" (m: $H/Static_Handle_Map($N, $T, $Handle_Type)) -> uint {…}

Returns the capacity of the items in a handle map. This is equivalent to `N-1` as the zero value is reserved for the zero-value sentinel.

static_clear #

static_clear :: proc "contextless" (m: ^$H/Static_Handle_Map($N, $T, $Handle_Type)) {…}

`clear` the handle map by zeroing all of the memory. Internally this does not do `m^ = {}` but rather uses `intrinsics.mem_zero` explicitly improve performance.

static_get #

@(require_results)

static_get :: proc "contextless" (m: ^$H/Static_Handle_Map($N, $T, $Handle_Type), h: $Handle_Type) -> ($$deferred_return, bool) #optional_ok {…}

`get` a stable pointer of type `^T` by resolving the handle `h`. If the handle is not valid, then `nil, false` is returned.

static_is_valid #

@(require_results)

static_is_valid :: proc "contextless" (m: $H/Static_Handle_Map($N, $T, $Handle_Type), h: $Handle_Type) -> bool {…}

Returns true when the handle `h` is valid relating to the handle map.

static_iterate #

@(require_results)

static_iterate :: proc "contextless" (it: ^$HI/Static_Handle_Map_Iterator($H)) -> (val: $$deferred_return, h: $$deferred_return, ok: bool) {…}

Iterate over a handle map. It will skip over unused item slots (e.g. handle.idx == 0). Usage: it := hm.iterator_make(&the_handle_map) for item, handle in hm.iterate(&it) { ... }

static_iterator_make #

@(require_results)

static_iterator_make :: proc "contextless" (m: ^$H/Static_Handle_Map($N, $T, $Handle_Type)) -> $$deferred_return {…}

Makes an iterator from a handle map.

static_len #

@(require_results)

static_len :: proc "contextless" (m: $H/Static_Handle_Map($N, $T, $Handle_Type)) -> uint {…}

Returns the number of possibly valid items in the handle map.

static_remove #

static_remove :: proc "contextless" (m: ^$H/Static_Handle_Map($N, $T, $Handle_Type), h: $Handle_Type) -> bool {…}

`remove` an item from the handle map from the handle `h`.

Procedure Groups

9

add #

add :: proc{
	static_add,
	dynamic_add,
}

cap #

cap :: proc{
	static_cap,
	dynamic_cap,
}

clear #

clear :: proc{
	static_clear,
	dynamic_clear,
}

get #

get :: proc{
	static_get,
	dynamic_get,
}

is_valid #

is_valid :: proc{
	static_is_valid,
	dynamic_is_valid,
}

iterate #

iterate :: proc{
	static_iterate,
	dynamic_iterate,
}

iterator_make #

iterator_make :: proc{
	static_iterator_make,
	dynamic_iterator_make,
}

len #

len :: proc{
	static_len,
	dynamic_len,
}

remove #

remove :: proc{
	static_remove,
	dynamic_remove,
}