core/container/handle_map

container_handle_map

Types

Dynamic_Handle_Map :: struct {}Source

Dynamic_Handle_Map_Iterator :: struct {}Source

An iterator for a handle map.

Handle16 :: struct {
	idx: u8,
	gen: u8,
}

Source

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

Handle32 :: struct {
	idx: u16,
	gen: u16,
}

Source

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

Handle64 :: struct {
	idx: u32,
	gen: u32,
}

Source

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 :: struct {}Source

Static_Handle_Map_Iterator :: struct {}Source

An iterator for a handle map.

Procedures

dynamic_add :: proc(m: ^D, item: T, loc = #caller_location) -> (handle: Handle_Type, err: runtime.Allocator_Error)Source

dynamic_cap :: proc(m: D) -> (uint)Source

dynamic_clear :: proc(m: ^D)Source

dynamic_destroy :: proc(m: ^D)Source

dynamic_get :: proc(m: ^D, h: Handle_Type) -> (^T, bool)Source

dynamic_init :: proc(m: ^D, allocator: runtime.Allocator)Source

dynamic_is_valid :: proc(m: ^D, h: Handle_Type) -> (bool)Source

dynamic_iterate :: proc(it: ^DHI) -> (val: ^T, h: Handle_Type, ok: bool)Source

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 :: proc(m: ^D) -> (Dynamic_Handle_Map_Iterator(D))Source

Makes an iterator from a handle map.

dynamic_len :: proc(m: D) -> (uint)Source

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

dynamic_remove :: proc(m: ^D, h: Handle_Type, loc = #caller_location) -> (found: bool, err: runtime.Allocator_Error)Source

static_add :: proc(m: ^H, item: T) -> (handle: Handle_Type, ok: bool)Source

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 :: proc(m: H) -> (uint)Source

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 :: proc(m: ^H)Source

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 :: proc(m: ^H, h: Handle_Type) -> (^T, bool)Source

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 :: proc(m: H, h: Handle_Type) -> (bool)Source

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

static_iterate :: proc(it: ^HI) -> (val: ^T, h: Handle_Type, ok: bool)Source

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 :: proc(m: ^H) -> (Static_Handle_Map_Iterator(H))Source

Makes an iterator from a handle map.

static_len :: proc(m: H) -> (uint)Source

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

static_remove :: proc(m: ^H, h: Handle_Type) -> (bool)Source

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

Procedure Groups

add :: proc{static_add, dynamic_add}Source

cap :: proc{static_cap, dynamic_cap}Source

clear :: proc{static_clear, dynamic_clear}Source

get :: proc{static_get, dynamic_get}Source

is_valid :: proc{static_is_valid, dynamic_is_valid}Source

iterate :: proc{static_iterate, dynamic_iterate}Source

iterator_make :: proc{static_iterator_make, dynamic_iterator_make}Source

len :: proc{static_len, dynamic_len}Source

remove :: proc{static_remove, dynamic_remove}Source

container_handle_map

Types

Procedures

Procedure Groups

Find anything

Settings