Enum static_reflect::types::TypeInfo

pub enum TypeInfo<'a> {
    Unit,
    Never,
    Bool,
    Integer {
        size: IntSize,
        signed: bool,
    },
    Float {
        size: FloatSize,
    },
    Slice {
        element_type: &'a TypeInfo<'a>,
    },
    Str,
    Optional(&'a TypeInfo<'a>),
    Pointer,
    Structure(&'a StructureDef<'a>),
    Union(&'a UnionDef<'a>),
    Extern {
        name: &'static str,
    },
    Magic {
        id: &'static &'static str,
        extra: Option<&'a TypeInfo<'a>>,
    },
}

A type whose representation is known via reflection

These are usually defined statically via [StaticReflect

However, they can be allocated at runtime, and potentially live for a more limited lifetime.

Variants

Unit

The zero-length unit type ()

Used for functions that return nothing

Never

An impossible type,

The mere existence of this type at runtime is undefined behavior. Functions that have this as their return type never actually return.

Bool

A boolean

Like a Rust bool, values must be either zero or one. Anything else is undefined behavior.

Integer

An integer

Fields of Integer

size: IntSize

The size of the integer

signed: bool

If the integer is signed

Float

A floating point number

Fields of Float

size: FloatSize

The size/precision of the float

Slice

A slice of memory, represented as pointer + length

The element type is needed, since array indexing implicitly multiples by the size of the memory.

Representation should match the AsmSlice type

Fields of Slice

element_type: &'a TypeInfo<'a>

The type of the inner element

Str

A pointer to a UTF8 encoded string and length, just like Rust’s ‘str’ type

Internally represented by the AsmStr structure

Optional(&'a TypeInfo<'a>)

A very simple optional, represented as an AsmOption

This never uses the null pointer optimization

Pointer

An untyped pointer

This may be null.

Untyped pointers simplify the type system significantly. They also avoid cycles when defining structures in case a structure contains a pointer to itself.

Structure(&'a StructureDef<'a>)

A structure

Union(&'a UnionDef<'a>)

An untagged union

Extern

A named, transparent, extern type

Fields of Extern

name: &'static str

The name of the type

Since this is all we have, it’s what used to disambiguate between them.

Magic

A ‘magic’ type, with a user-defined meaning

This allows extensions to the type system

Fields of Magic

id: &'static &'static str

The id of the magic type, giving more information about how its implemented and what it actually means.

extra: Option<&'a TypeInfo<'a>>

Extra information (if any)

Implementations

impl TypeInfo<'static>

pub const F32: Self

A 32-bit, single-precision float

pub const F64: Self

A 64-bit, double-precision float

pub const fn integer(size: usize, signed: bool) -> Self

An integer with the specified size and signed-ness

Panics if the size is invalid

impl<'tp> TypeInfo<'tp>

pub const fn size(&self) -> usize

The size of the type, in bytes

pub const fn alignment(&self) -> usize

The alignment of the type, matching std::mem::align_of

Trait Implementations

impl<'a> Clone for TypeInfo<'a>

fn clone(&self) -> TypeInfo<'a>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Copy for TypeInfo<'a>

impl<'a> Debug for TypeInfo<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Display for TypeInfo<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Eq for TypeInfo<'a>

impl<'tp> From<&'tp TypeInfo<'tp>> for TypeId<'tp>

fn from(static_type: &'tp TypeInfo<'tp>) -> Self

Performs the conversion.

impl<'a> Hash for TypeInfo<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq<TypeInfo<'a>> for TypeInfo<'a>

fn eq(&self, other: &TypeInfo<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &TypeInfo<'a>) -> bool

This method tests for !=.

impl<'a> StructuralEq for TypeInfo<'a>

impl<'a> StructuralPartialEq for TypeInfo<'a>