Struct bevy::reflect::utility::GenericTypeCell

pub struct GenericTypeCell<T>(/* private fields */)
where
    T: TypedProperty;

A container for TypedProperty over generic types, allowing instances to be stored statically.

This is specifically meant for use with generic types. If your type isn’t generic, then use NonGenericTypeCell instead as it should be much more performant.

#[derive(TypePath)] and impl_type_path should always be used over GenericTypePathCell where possible.

Examples

Implementing TypeInfo with generics.

use bevy_reflect::utility::GenericTypeInfoCell;

struct Foo<T>(T);

impl<T: Reflect + TypePath> Typed for Foo<T> {
    fn type_info() -> &'static TypeInfo {
        static CELL: GenericTypeInfoCell = GenericTypeInfoCell::new();
        CELL.get_or_insert::<Self, _>(|| {
            let fields = [UnnamedField::new::<T>(0)];
            let info = TupleStructInfo::new::<Self>(&fields);
            TypeInfo::TupleStruct(info)
        })
    }
}

Implementing TypePath with generics.

use bevy_reflect::utility::GenericTypePathCell;

struct Foo<T>(T);

impl<T: TypePath> TypePath for Foo<T> {
    fn type_path() -> &'static str {
        static CELL: GenericTypePathCell = GenericTypePathCell::new();
        CELL.get_or_insert::<Self, _>(|| format!("my_crate::foo::Foo<{}>", T::type_path()))
    }
     
    fn short_type_path() -> &'static str {
        static CELL: GenericTypePathCell = GenericTypePathCell::new();
        CELL.get_or_insert::<Self, _>(|| format!("Foo<{}>", T::short_type_path()))
    }

    fn type_ident() -> Option<&'static str> {
        Some("Foo")
    }

    fn module_path() -> Option<&'static str> {
        Some("my_crate::foo")
    }

    fn crate_name() -> Option<&'static str> {
        Some("my_crate")
    }
}

Implementations

impl<T> GenericTypeCell<T>

where T: TypedProperty,

pub const fn new() -> GenericTypeCell<T>

Initialize a GenericTypeCell for generic types.

pub fn get_or_insert<G, F>(&self, f: F) -> &<T as TypedProperty>::Stored

where G: Any + ?Sized, F: FnOnce() -> <T as TypedProperty>::Stored,

Returns a reference to the TypedProperty stored in the cell.

This method will then return the correct TypedProperty reference for the given type T. If there is no entry found, a new one will be generated from the given function.

Trait Implementations

impl<T> Default for GenericTypeCell<T>

where T: TypedProperty,

fn default() -> GenericTypeCell<T>

Returns the “default value” for a type.