Enum static_reflect::types::TypeInfo

pub enum TypeInfo<'a> {
    Unit,
    Never,
    Bool,
    Integer(IntType),
    Float {
        size: FloatSize,
    },
    Slice {
        element_type: &'a TypeInfo<'a>,
    },
    Str,
    Optional(&'a TypeInfo<'a>),
    Pointer,
    Structure(&'a StructureDef<'a>),
    UntaggedUnion(&'a UntaggedUnionDef<'a>),
    TaggedUnion(&'a TaggedUnionDef<'a>),
    CStyleEnum(&'a CStyleEnumDef<'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

Tuple Fields of Integer

0: IntType

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>

UntaggedUnion

An untagged union

Tuple Fields of UntaggedUnion

0: &'a UntaggedUnionDef<'a>

TaggedUnion

A tagged union with a well-defined Rust-compatible layout. See RFC #2195 for complete details on how #[repr(C)] enums are defined.

There are two different representations for tagged unions. See TaggedUnionStyle for details.

Tuple Fields of TaggedUnion

0: &'a TaggedUnionDef<'a>

CStyleEnum

A C-style enum, without any data.

See TypeInfo::TaggedUnion for enums with data.

Tuple Fields of CStyleEnum

0: &'a CStyleEnumDef<'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

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>