package core:reflect

Index

Variables (0)

This section is empty.

Procedures (99)
Procedure Groups (2)

Types

Enum_Field ¶

Enum_Field :: struct {
	name:  string,
	value: runtime.Type_Info_Enum_Value,
}

Map_Entry_Info ¶

Map_Entry_Info :: struct($Key: typeid, $Value: typeid) where intrinsics.type_is_valid_map_key(Key) {}

Struct_Field ¶

Struct_Field :: struct {
	name:     string,
	type:     ^runtime.Type_Info,
	tag:      Struct_Tag,
	offset:   uintptr,
	is_using: bool,
}

Struct_Tag ¶

Struct_Tag :: distinct string
 

Struct_Tag represents the type of the string of a struct field

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

Type_Info ¶

Type_Info :: runtime.Type_Info

Type_Info_Any ¶

Type_Info_Any :: runtime.Type_Info_Any

Type_Info_Array ¶

Type_Info_Array :: runtime.Type_Info_Array

Type_Info_Bit_Set ¶

Type_Info_Bit_Set :: runtime.Type_Info_Bit_Set

Type_Info_Boolean ¶

Type_Info_Boolean :: runtime.Type_Info_Boolean

Type_Info_Complex ¶

Type_Info_Complex :: runtime.Type_Info_Complex

Type_Info_Dynamic_Array ¶

Type_Info_Dynamic_Array :: runtime.Type_Info_Dynamic_Array

Type_Info_Enum ¶

Type_Info_Enum :: runtime.Type_Info_Enum

Type_Info_Enum_Value ¶

Type_Info_Enum_Value :: runtime.Type_Info_Enum_Value

Type_Info_Float ¶

Type_Info_Float :: runtime.Type_Info_Float

Type_Info_Integer ¶

Type_Info_Integer :: runtime.Type_Info_Integer

Type_Info_Map ¶

Type_Info_Map :: runtime.Type_Info_Map

Type_Info_Matrix ¶

Type_Info_Matrix :: runtime.Type_Info_Matrix

Type_Info_Multi_Pointer ¶

Type_Info_Multi_Pointer :: runtime.Type_Info_Multi_Pointer

Type_Info_Named ¶

Type_Info_Named :: runtime.Type_Info_Named

Type_Info_Pointer ¶

Type_Info_Pointer :: runtime.Type_Info_Pointer

Type_Info_Procedure ¶

Type_Info_Procedure :: runtime.Type_Info_Procedure

Type_Info_Quaternion ¶

Type_Info_Quaternion :: runtime.Type_Info_Quaternion

Type_Info_Relative_Slice ¶

Type_Info_Relative_Slice :: runtime.Type_Info_Relative_Slice

Type_Info_Rune ¶

Type_Info_Rune :: runtime.Type_Info_Rune

Type_Info_Simd_Vector ¶

Type_Info_Simd_Vector :: runtime.Type_Info_Simd_Vector

Type_Info_Slice ¶

Type_Info_Slice :: runtime.Type_Info_Slice

Type_Info_Soa_Pointer ¶

Type_Info_Soa_Pointer :: runtime.Type_Info_Soa_Pointer

Type_Info_String ¶

Type_Info_String :: runtime.Type_Info_String

Type_Info_Struct ¶

Type_Info_Struct :: runtime.Type_Info_Struct

Type_Info_Tuple ¶

Type_Info_Tuple :: runtime.Type_Info_Tuple

Type_Info_Type_Id ¶

Type_Info_Type_Id :: runtime.Type_Info_Type_Id

Type_Info_Union ¶

Type_Info_Union :: runtime.Type_Info_Union

Type_Kind ¶

Type_Kind :: enum int {
	Invalid, 
	Named, 
	Integer, 
	Rune, 
	Float, 
	Complex, 
	Quaternion, 
	String, 
	Boolean, 
	Any, 
	Type_Id, 
	Pointer, 
	Multi_Pointer, 
	Procedure, 
	Array, 
	Enumerated_Array, 
	Dynamic_Array, 
	Slice, 
	Tuple, 
	Struct, 
	Union, 
	Enum, 
	Map, 
	Bit_Set, 
	Simd_Vector, 
	Relative_Pointer, 
	Relative_Slice, 
	Matrix, 
	Soa_Pointer, 
}

Constants

DEFAULT_EQUAL_MAX_RECURSION_LEVEL ¶

DEFAULT_EQUAL_MAX_RECURSION_LEVEL :: 32

Variables

This section is empty.

Procedures

align_of_typeid ¶

align_of_typeid :: proc "odin" (T: typeid) -> int {…}

any_base ¶

any_base :: proc "odin" (v: any) -> any {…}

any_core ¶

any_core :: proc "odin" (v: any) -> any {…}

any_data ¶

any_data :: proc "odin" (v: any) -> (data: rawptr, id: typeid) {…}

are_types_identical ¶

are_types_identical :: proc "odin" (a, b: ^runtime.Type_Info) -> bool {…}

as_bool ¶

as_bool :: proc "odin" (a: any) -> (value: bool, valid: bool) {…}

as_bytes ¶

as_bytes :: proc "odin" (v: any) -> []u8 {…}

as_f64 ¶

as_f64 :: proc "odin" (a: any) -> (value: f64, valid: bool) {…}

as_i64 ¶

as_i64 :: proc "odin" (a: any) -> (value: i64, valid: bool) {…}

as_int ¶

as_int :: proc "odin" (a: any) -> (value: int, valid: bool) {…}

as_pointer ¶

as_pointer :: proc "odin" (a: any) -> (value: rawptr, valid: bool) {…}

as_raw_data ¶

as_raw_data :: proc "odin" (a: any) -> (value: rawptr, valid: bool) {…}

as_string ¶

as_string :: proc "odin" (val: any) -> (string, bool) {…}

as_u64 ¶

as_u64 :: proc "odin" (a: any) -> (value: u64, valid: bool) {…}

as_uint ¶

as_uint :: proc "odin" (a: any) -> (value: uint, valid: bool) {…}

backing_type_kind ¶

backing_type_kind :: proc "odin" (T: typeid) -> Type_Kind {…}
 

TODO(bill): Better name

capacity ¶

capacity :: proc "odin" (val: any) -> int {…}

deref ¶

deref :: proc "odin" (v: any) -> any {…}

enum_field_names ¶

enum_field_names :: proc "odin" (T: typeid) -> []string {…}

enum_field_values ¶

enum_field_values :: proc "odin" (Enum_Type: typeid) -> []runtime.Type_Info_Enum_Value {…}

enum_fields_zipped ¶

enum_fields_zipped :: proc "odin" (Enum_Type: typeid) -> (fields: #soa[]) {…}

enum_from_name ¶

enum_from_name :: proc "odin" ($T: typeid, s: string) -> (typeid, bool) {…}
 

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

enum_from_name_any ¶

enum_from_name_any :: proc "odin" (Enum_Type: typeid, name: string) -> (value: runtime.Type_Info_Enum_Value, ok: bool) {…}

enum_string ¶

enum_string :: proc "odin" (a: any) -> string {…}

equal ¶

equal :: proc "odin" (a, b: any, including_indirect_array_recursion: bool = false, recursion_level: int = 0) -> bool {…}

get_union_as_ptr_variants ¶

get_union_as_ptr_variants :: proc "odin" (object: ^$) -> $ {…}

get_union_variant ¶

get_union_variant :: proc "odin" (v: any) -> any {…}

get_union_variant_raw_tag ¶

get_union_variant_raw_tag :: proc "odin" (a: any) -> i64 {…}

index ¶

index :: proc "odin" (val: any, i: int, loc := #caller_location) -> any {…}

is_any ¶

is_any :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_array ¶

is_array :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_bit_set ¶

is_bit_set :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_boolean ¶

is_boolean :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_byte ¶

is_byte :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_complex ¶

is_complex :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_cstring ¶

is_cstring :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_dynamic_array ¶

is_dynamic_array :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_dynamic_map ¶

is_dynamic_map :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_enum ¶

is_enum :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_enumerated_array ¶

is_enumerated_array :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_float ¶

is_float :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_integer ¶

is_integer :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_multi_pointer ¶

is_multi_pointer :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_nil ¶

is_nil :: proc "odin" (v: any) -> bool {…}

is_pointer ¶

is_pointer :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_pointer_internally ¶

is_pointer_internally :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_procedure ¶

is_procedure :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_quaternion ¶

is_quaternion :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_raw_union ¶

is_raw_union :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_relative_pointer ¶

is_relative_pointer :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_relative_slice ¶

is_relative_slice :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_rune ¶

is_rune :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_signed ¶

is_signed :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_simd_vector ¶

is_simd_vector :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_slice ¶

is_slice :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_soa_pointer ¶

is_soa_pointer :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_string ¶

is_string :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_struct ¶

is_struct :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_tuple ¶

is_tuple :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_union ¶

is_union :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

is_unsigned ¶

is_unsigned :: proc "odin" (info: ^runtime.Type_Info) -> bool {…}

length ¶

length :: proc "odin" (val: any) -> int {…}

map_entry_info_slice ¶

map_entry_info_slice :: proc "odin" (m: $T/map[$]$, allocator := context.allocator) -> (entries: []Map_Entry_Info(K, V)) {…}

not_equal ¶

not_equal :: proc "odin" (a, b: any, including_indirect_array_recursion: bool = false, recursion_level: int = 0) -> bool {…}

relative_pointer_to_absolute ¶

relative_pointer_to_absolute :: proc "odin" (a: any) -> rawptr {…}

relative_pointer_to_absolute_raw ¶

relative_pointer_to_absolute_raw :: proc "odin" (data: rawptr, base_integer_id: typeid) -> rawptr {…}

set_union_value ¶

set_union_value :: proc "odin" (dst: any, value: any) -> bool {…}

set_union_variant_raw_tag ¶

set_union_variant_raw_tag :: proc "odin" (a: any, tag: i64) {…}

set_union_variant_type_info ¶

set_union_variant_type_info :: proc "odin" (a: any, tag_ti: ^runtime.Type_Info) {…}

set_union_variant_typeid ¶

set_union_variant_typeid :: proc "odin" (a: any, id: typeid) {…}

size_of_typeid ¶

size_of_typeid :: proc "odin" (T: typeid) -> int {…}

struct_field_at ¶

struct_field_at :: proc "odin" (T: typeid, i: int) -> (field: Struct_Field) {…}

struct_field_by_name ¶

struct_field_by_name :: proc "odin" (T: typeid, name: string) -> (field: Struct_Field) {…}

struct_field_names ¶

struct_field_names :: proc "odin" (T: typeid) -> []string {…}

struct_field_offsets ¶

struct_field_offsets :: proc "odin" (T: typeid) -> []uintptr {…}

struct_field_tags ¶

struct_field_tags :: proc "odin" (T: typeid) -> []Struct_Tag {…}

struct_field_types ¶

struct_field_types :: proc "odin" (T: typeid) -> []^runtime.Type_Info {…}

struct_field_value_by_name ¶

struct_field_value_by_name :: proc "odin" (a: any, field: string, allow_using: bool = false) -> any {…}

struct_fields_zipped ¶

struct_fields_zipped :: proc "odin" (T: typeid) -> (fields: #soa[]) {…}

struct_tag_get ¶

struct_tag_get :: proc "odin" (tag: Struct_Tag, key: string) -> (value: Struct_Tag) {…}

struct_tag_lookup ¶

struct_tag_lookup :: proc "odin" (tag: Struct_Tag, key: string) -> (value: Struct_Tag, ok: bool) {…}

type_info_base ¶

type_info_base :: proc "odin" (info: ^runtime.Type_Info) -> ^runtime.Type_Info {…}

type_info_base_without_enum ¶

type_info_base_without_enum :: type_info_core

type_info_core ¶

type_info_core :: proc "odin" (info: ^runtime.Type_Info) -> ^runtime.Type_Info {…}

type_info_union_is_pure_maybe ¶

type_info_union_is_pure_maybe :: proc "odin" (info: runtime.Type_Info_Union) -> bool {…}

type_kind ¶

type_kind :: proc "odin" (T: typeid) -> Type_Kind {…}

typeid_base ¶

typeid_base :: proc "odin" (id: typeid) -> typeid {…}

typeid_base_without_enum ¶

typeid_base_without_enum :: typeid_core

typeid_core ¶

typeid_core :: proc "odin" (id: typeid) -> typeid {…}

typeid_elem ¶

typeid_elem :: proc "odin" (id: typeid) -> typeid {…}

underlying_type_kind ¶

underlying_type_kind :: proc "odin" (T: typeid) -> Type_Kind {…}
 

TODO(bill): Better name

union_variant_type_info ¶

union_variant_type_info :: proc "odin" (a: any) -> ^runtime.Type_Info {…}

union_variant_typeid ¶

union_variant_typeid :: proc "odin" (a: any) -> typeid {…}

write_type_builder ¶

write_type_builder :: proc "odin" (buf: ^strings.Builder, ti: ^runtime.Type_Info) -> int {…}

write_type_writer ¶

write_type_writer :: proc "odin" (w: io.Writer, ti: ^runtime.Type_Info, n_written: ^int = nil) -> (n: int, err: io.Error) {…}

write_typeid_builder ¶

write_typeid_builder :: proc "odin" (buf: ^strings.Builder, id: typeid, n_written: ^int = nil) -> (n: int, err: io.Error) {…}

write_typeid_writer ¶

write_typeid_writer :: proc "odin" (writer: io.Writer, id: typeid, n_written: ^int = nil) -> (n: int, err: io.Error) {…}

Procedure Groups

Source Files

Generation Information

Generated with odin version dev-2022-10 (vendor "odin") Windows_amd64 @ 2022-10-05 21:11:47.492418600 +0000 UTC