package core:reflect

Source

Represents an Enum_Field storing the name and value

Struct_Field represents a information of a field of a struct

• struct_field_value

• struct_field_at
• struct_field_by_name

Struct_Field_Count_Method is the count method used by struct_field_count in order to find the number of fields

• struct_field_count

Struct_Tag represents the type of the string of a struct field

Through convention, tags are the concatenation of optionally space-separated key:"value" pairs. Each key is a non-empty string which contains no control characters other than space, quotes, and colon.

• struct_tag_get
• struct_tag_lookup

• are_types_identical
• is_any
• is_array
• is_bit_set
• is_boolean
• is_byte
• is_complex
• is_cstring
• is_cstring16
• is_dynamic_array
• is_dynamic_map
• is_endian_big
• is_endian_little
• is_endian_platform
• is_enum
• is_enumerated_array
• is_float
• is_integer
• is_multi_pointer
• is_parameters
• is_pointer
• is_pointer_internally
• is_procedure
• is_quaternion
• is_raw_union
• is_rune
• is_signed
• is_simd_vector
• is_slice
• is_soa_pointer
• is_string
• is_string16
• is_struct
• is_union
• is_unsigned
• set_union_variant_type_info
• write_type_builder
• write_type_writer
• write_type (procedure groups)

• union_variant_type_info

• enum_from_name_any

• type_info_union_is_pure_maybe

• backing_type_kind
• type_kind
• underlying_type_kind

returns the alignment of the type that the passed typeid represents

any_base returns an any where the typeid has been replaced with the base-type equivalent

any_core returns an any where the typeid has been replaced with the core-type equivalent

Splits the data stored in any into its two components: data and id

Returns true when the ^Type_Infos are semantically equivalent types Note: The pointers being identical should be enough to check but this is done to make sure in certain cases where it is non-trivial and each value wants to be checked directly.

as_bool attempts to convert an any to a bool.

Reinterprets the data stored at v as a slice of bytes

as_f64 attempts to convert an any to a f64.

as_i64 attempts to convert an any to a i64.

as_int attempts to convert an any to a int.

as_pointer attempts to convert an any to a rawptr. This only works for ^T, [^]T, cstring, cstring16 based types

Returns the equivalent of doing raw_data(v) where v is a non-any value

as_string attempts to convert an any to a string.

as_string16 attempts to convert an any to a string16.

as_u64 attempts to convert an any to a u64.

as_uint attempts to convert an any to a uint.

Returns the Type_Kind of the core-type of a typeid. See

bit_field_names returns a []string of the field names of a bit_field type T

bit_field_types returns a []uintptr of the field offsets in bits of a bit_field type T

bit_field_types returns a []uintptr of the field bit-width-sizes of a bit_field type T

bit_field_types returns a []Struct_Tag of the field tags of a bit_field type T

bit_field_types returns a []^Type_Info of the field representation types of a bit_field type T, not the backing integer-bit-width types

Returns the fields of a bit_field type T as an #soa slice. This is useful to iterate over.

for field, i in reflect.bit_fields_zipped(Foo_Bit_Field) { ... }

UNSAFE: Checks to see if the data stored is a bit_set and is big endian. Panics if a bit_set was not passed.

Returns the capacity of the type that represents the any value, or returns 0 if not possible cap(^T) -> cap(T) cap([N]T) -> N cap(#simd[N]T) -> N cap([dynamic]T) cap(map[K]V)

Dereferences any if it represents a pointer-based value (^T -> T)

enum_field_names returns []string of the names of the fields of type Enum_Type

enum_field_values returns []Type_Info_Enum_Value of the values of the fields of type Enum_Type

Returns a #soa slice of the enum field information of type Enum_Type This is useful to iterate over.

for field, i in reflect.enum_fields_zipped(Foo) { ... }

Given an enum type and a value name, get the enum value.

enum_from_name_any returns the value of an enum field's name if found, returns 0, false otherwise.

enum_name_from_value returns the name of enum field if a valid name using parametric polymorphism, otherwise returns "", false

enum_name_from_value_any returns the name of enum field if a valid name using reflection, otherwise returns "", false

Returns the string representation of an enum value. It will panic if the value passed is not an enum.

Returns whether the value given has a defined name in the enum type.

Checks to see if two any values are semantically equivalent

Checks to see if two any values are semantically equivalent

Converts a pointer to a union, to a union containing the pointers to the variant types, and stores a pointer of the variant value in the new union

val: union{i32, f32, string}
val = "123"
ptr: union{^i32, ^f32, ^string} = get_union_as_ptr_variants(&val)
sp := ptr.(^string)
assert(sp^ == "123")

Returns the underlying variant value of a union. Panics if a union was not passed.

UNSAFE: Returns the underlying tag value of a union. Panics if a union was not passed.

Dynamically indexes any as an indexable-type if possible. Returns nil if not possible

Returns true the base-type is an any, false otherwise.

Returns true when the type is a fixed-array type ([N]T), false otherwise.

Returns true when the type is a bit_set type, false otherwise.

Returns true the base-type is a boolean of any kind, false otherwise.

Returns true when it is a 1-byte wide integer type, false otherwise.

Returns true the base-type is a complex-type of any kind, false otherwise.

Returns true the base-type is a cstring of any kind (cstring, cstring16), false otherwise.

Returns true the base-type is a cstring of any kind (cstring16), false otherwise.

Returns true when the type is a dynamic-array type ([dynamic]T), false otherwise.

Returns true when the type is a map type (map[K]V), false otherwise.

Returns true when the core-type is represented with a platform-native endian type or the same endianness as the system. This will also return false when the type is not an integer, pointer, or bit_set. If the type is the same as the platform-native endian type (e.g. u32be on a big-endian system), this will return true.

Returns true when the core-type is represented with a platform-native endian type or the same endianness as the system. This will also return false when the type is not an integer, pointer, or bit_set. If the type is the same as the platform-native endian type (e.g. u32le on a little-endian system), this will return true.

Returns true when the core-type is represented with a platform-native endian type, and returns false otherwise. This will also return false when the type is not an integer, pointer, or bit_set. If the type is the same as the platform-native endian type (e.g. u32le on a little-endian system), this will return false.

Returns true when the type is an enum type, false otherwise.

Returns true when the type is an enumerated-array type ([Enum]T), false otherwise.

Returns true the base-type is a float of any kind, false otherwise.

Returns true the base-type is an integer of any kind, false otherwise.

Returns true the base-type is a pointer-type of any kind ([^]T), false otherwise.

Returns true if the any value is either nil or the data stored at the address is all zeroed

Returns true when the type represents a set of parameters for a procedure (inputs or outputs), false otherwise.

Returns true the base-type is a pointer-type of any kind (^T or rawptr), false otherwise.

Returns true when the type is a pointer-like type, false otherwise.

Returns true when the type is a procedure type, false otherwise.

Returns true the base-type is a quaternions any kind, false otherwise.

Returns true when the type is a struct type with #raw_union applied, when #raw_union is not applied, the value will be false. All other types will be false otherwise.

Returns true the base-type is a rune, false otherwise.

Returns true if the base-type is a signed integer or just a float, false otherwise.

Returns true when the type is a #simd-array type (#simd[N]T), false otherwise.

Returns true when the type is a slice type ([]T), false otherwise.

Returns true the base-type is a pointer-type of any kind (#soa^T), false otherwise.

Returns true the base-type is a string of any kind (string, cstring, string16, cstring16), false otherwise.

Returns true the base-type is a string of any kind (string16, cstring16), false otherwise.

Returns true when the type is a struct type, #raw_union will be false. All other types will be false otherwise.

Returns true when the type is a union type (not #raw_union), false otherwise.

Returns true if the base-type is an usigned integer, false otherwise.

An iterator to dynamically iterate across something that is array-like (or pointer-to-array-like)

it: int // used as a tracking value
for elem, idx in iterate_array(any_array_val, &it) { ... }

An iterator to dynamically iterate across map (or pointer-to-map)

it: int // used as a tracking value
for key, val in iterate_map(any_map_val, &it) { ... }

Returns the length of the type that represents the any value, or returns 0 if not possible len(^T) -> len(T) len([N]T) -> N len(#simd[N]T) -> N len([]T) len([dynamic]T) len(map[K]V) len(string) or len(cstring) len(string16) or len(cstring16)

Checks to see if two any values are not semantically equivalent

Checks to see if two any values are not semantically equivalent

UNSAFE: Manually set the variant value of a union using an any. Panics if a union was not passed.

UNSAFE: Manually set the tag value of a union using an integer. Panics if a union was not passed.

UNSAFE: Manually set the tag value of a union using a ^Type_Info. Panics if a union was not passed.

UNSAFE: Manually set the tag value of a union using a typeid. Panics if a union was not passed.

returns the size of the type that the passed typeid represents

Returns a Struct_Field containing the information for a struct field of a typeid T at index i

Returns a Struct_Field containing the information for a struct field by name of a typeid T

Counts the number of fields in a struct

This procedure returns the number of fields in a struct, counting in one of three ways: .Top_Level: Only counts the top-level fields .Using: Same count as .Top_Level, and adds the field count of any using s: Struct it encounters (in addition to itself) .Recursive: The count of all top-level fields, plus the count of any child struct's fields, recursively

Inputs:
T: The struct type method: The counting method

Returns:
The count, enumerated using the method, which will be 0 if the type is not a struct

symbols_loaded, ok := dynlib.initialize_symbols(&game_api, "game.dll")
symbols_expected   := reflect.struct_field_count(Game_Api) - API_PRIVATE_COUNT

if symbols_loaded != symbols_expected {
	fmt.eprintf("Expected %v symbols, got %v", symbols_expected, symbols_loaded)
	return
}

Returns a []string of the names of the struct fields of type T

Returns a []uintptr of the offsets in bytes of the struct fields of type T

Returns a []Struct_Tag of the tags of the struct fields of type T

Returns a []^Type_Info of the types of the struct fields of type T

Returns an any of a struct field specified by a Struct_Field

field := struct_field_value_by_name(the_struct, "field_name")
value_by_field := struct_field_value(the_struct, field)

Returns an any of a struct field specified by name

v := struct_field_value_by_name(the_struct, "field_name")
nested_value_through_using := struct_field_value_by_name(the_struct, "field_name", allow_using=true)

Returns the fields of a struct type T as an #soa slice. This is useful to iterate over.

for field, i in reflect.struct_fields_zipped(Foo) { ... }

struct_tag_get returns the value associated with a key in the tag string. If the key is present in the tag, the value (which might be empty) is returned. Otherwise an empty string is returned. This is just a wrapper around struct_tag_lookup with the ok value being ignored.

The convention for struct tags is usually of the form:

`key:"value" another:"set" and:"whatever"`

struct_tag_lookup returns the value associated with a key in the tag string. If the key is present in the tag, the value (which might be empty) is return. Otherwise an empty string is returned. The ok value returns whether the value was explicit set in the tag string.

The convention for struct tags is usually of the form:

`key:"value" another:"set" and:"whatever"`

Returns whether the Type_Info_Union store no tag (called a "pure maybe").

type_kind returns a enum Type_Kind to state what kind of type a typeid is

typeid_elem returns a typeid of the element-type of a type if possible, otherwise it returns itself complex32 -> f16 complex64 -> f32 complex128 -> f64 quaternion64 -> f16 quaternion128 -> f32 quaternion256 -> f64 ^T -> T [^]T -> T #soa^T -> T [N]T -> T []T -> T [dynamic]T -> T #simd[N]T -> T

Returns the Type_Kind of the base-type of a typeid.

Returns ^Type_Info of a any-encoded union type. Panics if a union was not passed.

UNSAFE: Returns typeid of a any-encoded union type. Panics if a union was not passed.

Writes a ^Type_Info in standard (non-canonical) form to a strings.Builder

• write_type

Writes a ^Type_Info in standard (non-canonical) form to an io.Writer

• write_type

Writes a typeid in standard (non-canonical) form to a strings.Builder

• write_typeid

Writes a typeid in standard (non-canonical) form to an io.Writer

• write_typeid

Writes a ^Type_Info in standard (non-canonical) form

Writes a typeid in standard (non-canonical) form