package core:reflect

Source

Bit_Field :: struct {
	name:   string,
	type:   ^runtime.Type_Info,
	size:   uintptr,
	// Size in bits
	offset: uintptr,
	// Offset in bits
	tag:    Struct_Tag,
}

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

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

Struct_Field_Count_Method :: enum int {
	Top_Level, 
	Using, 
	Recursive, 
}

Struct_Tag :: distinct string

Type_Info :: runtime.Type_Info

Type_Info_Any :: runtime.Type_Info_Any

Type_Info_Array :: runtime.Type_Info_Array

Type_Info_Bit_Field :: runtime.Type_Info_Bit_Field

Type_Info_Bit_Set :: runtime.Type_Info_Bit_Set

Type_Info_Boolean :: runtime.Type_Info_Boolean

Type_Info_Complex :: runtime.Type_Info_Complex

Type_Info_Dynamic_Array :: runtime.Type_Info_Dynamic_Array

Type_Info_Enum :: runtime.Type_Info_Enum

Type_Info_Enum_Value :: runtime.Type_Info_Enum_Value

Type_Info_Enumerated_Array :: runtime.Type_Info_Enumerated_Array

Type_Info_Float :: runtime.Type_Info_Float

Type_Info_Integer :: runtime.Type_Info_Integer

Type_Info_Map :: runtime.Type_Info_Map

Type_Info_Matrix :: runtime.Type_Info_Matrix

Type_Info_Multi_Pointer :: runtime.Type_Info_Multi_Pointer

Type_Info_Named :: runtime.Type_Info_Named

Type_Info_Parameters :: runtime.Type_Info_Parameters

Type_Info_Pointer :: runtime.Type_Info_Pointer

Type_Info_Procedure :: runtime.Type_Info_Procedure

Type_Info_Quaternion :: runtime.Type_Info_Quaternion

Type_Info_Rune :: runtime.Type_Info_Rune

Type_Info_Simd_Vector :: runtime.Type_Info_Simd_Vector

Type_Info_Slice :: runtime.Type_Info_Slice

Type_Info_Soa_Pointer :: runtime.Type_Info_Soa_Pointer

Type_Info_String :: runtime.Type_Info_String

Type_Info_Struct :: runtime.Type_Info_Struct

Type_Info_Tuple :: runtime.Type_Info_Parameters

Type_Info_Type_Id :: runtime.Type_Info_Type_Id

Type_Info_Union :: runtime.Type_Info_Union

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, 
	Matrix, 
	Soa_Pointer, 
	Bit_Field, 
}

DEFAULT_EQUAL_MAX_RECURSION_LEVEL :: 32

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

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

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

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

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

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

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

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

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

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

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

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

as_string :: proc(a: any) -> (value: string, valid: bool) {…}

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

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

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

bit_field_names :: proc(T: typeid) -> []string {…}

bit_field_offsets :: proc(T: typeid) -> []uintptr {…}

bit_field_sizes :: proc(T: typeid) -> []uintptr {…}

bit_field_tags :: proc(T: typeid) -> []Struct_Tag {…}

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

bit_fields_zipped :: proc(T: typeid) -> (fields: #soa[]Bit_Field) {…}

bit_set_is_big_endian :: proc(value: any, loc := #caller_location) -> bool {…}

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

deref :: proc(val: any) -> any {…}

enum_field_names :: proc(Enum_Type: typeid) -> []string {…}

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

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

enum_from_name :: proc($Enum_Type: typeid, name: string) -> (value: typeid, ok: bool) {…}

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

enum_name_from_value :: proc(value: $T) -> (name: string, ok: bool) {…}

enum_name_from_value_any :: proc(value: any) -> (name: string, ok: bool) {…}

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

enum_value_has_name :: proc(value: $T) -> bool {…}

eq :: equal

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

get_union_as_ptr_variants :: proc(val: ^$T) -> (res: $T) {…}

get_union_variant :: proc(a: any) -> any {…}

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

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

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

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

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

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

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

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

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

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

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

is_endian_big :: proc(info: ^runtime.Type_Info) -> bool {…}

is_endian_little :: proc(info: ^runtime.Type_Info) -> bool {…}

is_endian_platform :: proc(info: ^runtime.Type_Info) -> bool {…}

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

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

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

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

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

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

is_parameters :: proc(info: ^runtime.Type_Info) -> bool {…}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

iterate_array :: proc(val: any, it: ^int) -> (elem: any, index: int, ok: bool) {…}

iterate_map :: proc(val: any, it: ^int) -> (key, value: any, ok: bool) {…}

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

ne :: not_equal

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

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

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

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

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

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

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

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

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

struct_field_count :: proc(T: typeid, method: Struct_Field_Count_Method = Struct_Field_Count_Method.Top_Level) -> (count: int) {…}

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

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

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

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

struct_field_value :: proc(a: any, field: Struct_Field) -> any {…}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

write_type :: proc{
	write_type_builder,
	write_type_writer,
}

write_typeid :: proc{
	write_typeid_builder,
	write_typeid_writer,
}