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 very simple optional, represented as an AsmOption

This never uses the null pointer optimization

Tuple Fields of Optional

0: &'a TypeInfo<'a>

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 structure

Tuple Fields of Structure

0: &'a StructureDef<'a>

Union

An untagged union

Tuple Fields of Union

0: &'a UnionDef<'a>

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.

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

Performs copy-assignment from source.

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<'tp> From<&'tp TypeInfo<'tp>> for TypeId<'tp>

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

Performs the conversion.

impl<'a, 'min, Id: CollectorId> GcErase<'min, Id> for TypeInfo<'a> where
    'a: 'min, 

type Erased = Self

This type with all garbage collected lifetimes changed to 'static (or erased)

impl<'a, 'new_gc, Id: CollectorId> GcRebrand<'new_gc, Id> for TypeInfo<'a> where
    'a: 'new_gc, 

type Branded = Self

This type with all garbage collected lifetimes changed to 'new_gc

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

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

Feeds this value into the given Hasher.

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> Trace for TypeInfo<'a>

const NEEDS_TRACE: bool

Whether this type needs to be traced by the garbage collector.

const NEEDS_DROP: bool

If this type needs a destructor run.

fn visit<Visitor: GcVisitor + ?Sized>(
    &mut self,
    visitor: &mut Visitor
) -> Result<(), Visitor::Err>

Visit each field in this type

unsafe fn visit_inside_gc<'actual_gc, Visitor, ActualId>(
    gc: &mut Gc<'actual_gc, Self, ActualId>,
    visitor: &mut Visitor
) -> Result<(), Visitor::Err> where
    Visitor: GcVisitor,
    ActualId: CollectorId,
    Self: GcSafe + 'actual_gc, 

Visit this object, assuming its already inside a GC pointer.

impl<'a> TraceImmutable for TypeInfo<'a>

fn visit_immutable<Visitor: GcVisitor + ?Sized>(
    &self,
    visitor: &mut Visitor
) -> Result<(), Visitor::Err>

Visit an immutable reference to this type

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

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

impl<'a> GcSafe for TypeInfo<'a>

impl<'a> NullTrace for TypeInfo<'a>

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

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