Struct Type

pub struct Type { /* private fields */ }

The base representation of a Rust type.

When possible, it is recommended to use &'static TypeInfo instead of this as it provides more information as well as being smaller (since a reference only takes the same number of bytes as a usize).

However, where a static reference to TypeInfo is not possible, such as with trait objects and other types that can’t implement Typed, this type can be used instead.

It only requires that the type implements TypePath.

And unlike TypeInfo, this type implements Copy, Eq, and Hash, making it useful as a key type.

It’s especially helpful when compared to TypeId as it can provide the actual [type path] when debugging, while still having the same performance as hashing/comparing TypeId directly—at the cost of a little more memory.

Examples

use bevy_reflect::{Type, TypePath};

fn assert_char<T: ?Sized + TypePath>(t: &T) -> Result<(), String> {
    let ty = Type::of::<T>();
    if Type::of::<char>() == ty {
        Ok(())
    } else {
        Err(format!("expected `char`, got `{}`", ty.path()))
    }
}

assert_eq!(
    assert_char(&'a'),
    Ok(())
);
assert_eq!(
    assert_char(&String::from("Hello, world!")),
    Err(String::from("expected `char`, got `alloc::string::String`"))
);

Implementations

impl Type

pub fn of<T: TypePath + ?Sized>() -> Self

Create a new Type from a type that implements TypePath.

pub fn id(&self) -> TypeId

Returns the TypeId of the type.

pub fn path(&self) -> &'static str

See TypePath::type_path.

pub fn short_path(&self) -> &'static str

See TypePath::short_type_path.

pub fn ident(&self) -> Option<&'static str>

See TypePath::type_ident.

pub fn crate_name(&self) -> Option<&'static str>

See TypePath::crate_name.

pub fn module_path(&self) -> Option<&'static str>

See TypePath::module_path.

pub fn type_path_table(&self) -> &TypePathTable

A representation of the type path of this.

Provides dynamic access to all methods on TypePath.

pub fn is<T: Any>(&self) -> bool

Check if the given type matches this one.

This only compares the TypeId of the types and does not verify they share the same TypePath (though it implies they do).

Trait Implementations

impl Clone for Type

fn clone(&self) -> Type

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Type

This implementation will only output the type path of the type.

If you need to include the TypeId in the output, you can access it through Type::id.

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

Formats the value using the given formatter.

impl Hash for Type

This implementation purely relies on the TypeId of the type, and not on the type path.

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Type

This implementation purely relies on the TypeId of the type, and not on the type path.

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Type

impl Eq for Type