Enum rebound::ty::Type

pub enum Type {
    Primitive(PrimitiveInfo),
    Tuple(TupleInfo),
    Array(ArrayInfo),
    Slice(SliceInfo),
    Pointer(PointerInfo),
    Reference(ReferenceInfo),
    Function(FunctionInfo),
    Struct(StructInfo),
    TupleStruct(TupleStructInfo),
    UnitStruct(UnitStructInfo),
    Enum(EnumInfo),
    Union(UnionInfo),
}

An enum that represents information about a reflected type. This supports basically any possible type in Rust, including primitives, arrays, and references. Generally, the only requirement is that the type implement the Reflected trait, though most types are also expected to implement another trait related to information they possess not shared by other type kinds.

This is not, and cannot, be backed by core::any::TypeId, because that is only valid on 'static types, while this works with dynamic lifetimes.

Variants

Primitive(PrimitiveInfo)

A primitive simple type, such as u8 or str

Tuple(TupleInfo)

A tuple type, (T0, .., Tn)

Array(ArrayInfo)

An array type, [T; N]

Slice(SliceInfo)

A slice type, [T]

Pointer(PointerInfo)

A pointer type, either *const T or *mut T

Reference(ReferenceInfo)

A reference type, either &T or &mut T

Function(FunctionInfo)

A function pointer type, fn(T1..Tn) -> T0

Struct(StructInfo)

A struct type, with named fields

TupleStruct(TupleStructInfo)

A struct type, with unnamed fields

UnitStruct(UnitStructInfo)

A struct type, with no fields

Enum(EnumInfo)

An enum type, with variants

Union(UnionInfo)

A union type, with fields

Implementations

impl Type

pub unsafe fn new_struct<T: ?Sized + ReflectedStruct>()

Internal function used by generated code to initialize a Type for structs

Safety

Should only be called inside a Reflected type's init impl

pub unsafe fn new_tuple_struct<T: ReflectedTupleStruct>()

Internal function used by generated code to initialize a Type for tuple structs

Safety

Should only be called inside a Reflected type's init impl

pub unsafe fn new_unit_struct<T: ReflectedUnitStruct>()

Internal function used by generated code to initialize a Type for unit structs

Safety

Should only be called inside a Reflected type's init impl

pub unsafe fn new_enum<T: ReflectedEnum>()

Internal function used by generated code to initialize a Type for enums

Safety

Should only be called inside a Reflected type's init impl

pub unsafe fn new_union<T: ReflectedUnion>()

Internal function used by generated code to initialize a Type for unions

Safety

Should only be called inside a Reflected type's init impl

pub unsafe fn from_name(name: &str) -> Option<Type>

Get a Type instance by name, assuming it has been instantiated beforehand. The name provided is expected to be of a certain normalized form, which may not be fully stable between versions. Prefer Type::from if possible.

Current Requirements:

• All struct names should be fully qualified, so for example the Type for Type would be rebound::ty::Type
• Any commas will be followed by spaces, and there will be no trailing commas except in the case of 1-element tuples
• References will have no lifetime
• Possibly other things

Safety

This function is in no way memory unsafe, however, the format used for type names is an implementation detail, and thus may change even across patch versions.

pub fn from<T: ?Sized + Reflected>() -> Type

Get a Type instance from any reflected type, instantiating it if necessary.

pub fn unwrap_primitive(&self) -> &PrimitiveInfo

Get this Type as a PrimitiveInfo, panicking on failure.

pub fn unwrap_tuple(&self) -> &TupleInfo

Get this Type as a TupleInfo, panicking on failure.

pub fn unwrap_array(&self) -> &ArrayInfo

Get this Type as a ArrayInfo, panicking on failure.

pub fn unwrap_slice(&self) -> &SliceInfo

Get this Type as a SliceInfo, panicking on failure.

pub fn unwrap_pointer(&self) -> &PointerInfo

Get this Type as a PointerInfo, panicking on failure.

pub fn unwrap_reference(&self) -> &ReferenceInfo

Get this Type as a ReferenceInfo, panicking on failure.

pub fn unwrap_function(&self) -> &FunctionInfo

Get this Type as a FunctionInfo, panicking on failure.

pub fn unwrap_struct(&self) -> &StructInfo

Get this Type as a StructInfo, panicking on failure.

pub fn unwrap_tuple_struct(&self) -> &TupleStructInfo

Get this Type as a TupleStructInfo, panicking on failure.

pub fn unwrap_unit_struct(&self) -> &UnitStructInfo

Get this Type as a UnitStructInfo, panicking on failure.

pub fn unwrap_enum(&self) -> &EnumInfo

Get this Type as a EnumInfo, panicking on failure.

pub fn unwrap_union(&self) -> &UnionInfo

Get this Type as a UnionInfo, panicking on failure.

Trait Implementations

impl Clone for Type

pub fn clone(&self) -> Type

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CommonTypeInfo for Type

pub fn name(&self) -> String

Get this type's name

pub fn assoc_fns(&self) -> Vec<AssocFn>

Get the known associated functions of this type

pub fn assoc_consts(&self) -> Vec<AssocConst>

Get the known associated constants of this type

pub fn as_ref<'a>(&self, val: &'a Value<'_>) -> Result<Value<'a>, Error>

Convert a Value of this type to a reference to that value, if it's not already a reference

pub fn as_mut<'a>(&self, val: &'a mut Value<'_>) -> Result<Value<'a>, Error>

Convert a Value of this type to a mutable reference to that value, if it's not already a reference

impl Copy for Type

impl Debug for Type

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

Formats the value using the given formatter.

impl Eq for Type

impl Hash for Type

pub 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 PartialEq<Type> for Type

pub fn eq(&self, other: &Type) -> bool

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.