Struct bevy::reflect::TypeRegistry

pub struct TypeRegistry { /* private fields */ }

A registry of reflected types.

This struct is used as the central store for type information. Registering a type will generate a new TypeRegistration entry in this store using a type’s GetTypeRegistration implementation (which is automatically implemented when using #[derive(Reflect)]).

See the crate-level documentation for more information.

Implementations

impl TypeRegistry

pub fn empty() -> TypeRegistry

Create a type registry with no registered types.

pub fn new() -> TypeRegistry

Create a type registry with default registrations for primitive types.

pub fn register<T>(&mut self)

where T: GetTypeRegistration,

Attempts to register the type T if it has not yet been registered already.

This will also recursively register any type dependencies as specified by GetTypeRegistration::register_type_dependencies. When deriving Reflect, this will generally be all the fields of the struct or enum variant. As with any type registration, these type dependencies will not be registered more than once.

If the registration for type T already exists, it will not be registered again and neither will its type dependencies. To register the type, overwriting any existing registration, use register instead.

Additionally, this will add any reflect type data as specified in the Reflect derive.

Example

#[derive(Reflect, Default)]
#[reflect(Default)]
struct Foo {
  name: Option<String>,
  value: i32
}

let mut type_registry = TypeRegistry::default();

type_registry.register::<Foo>();

// The main type
assert!(type_registry.contains(TypeId::of::<Foo>()));

// Its type dependencies
assert!(type_registry.contains(TypeId::of::<Option<String>>()));
assert!(type_registry.contains(TypeId::of::<i32>()));

// Its type data
assert!(type_registry.get_type_data::<ReflectDefault>(TypeId::of::<Foo>()).is_some());

pub fn add_registration(&mut self, registration: TypeRegistration) -> bool

Attempts to register the type described by registration.

If the registration for the type already exists, it will not be registered again.

To forcibly register the type, overwriting any existing registration, use the overwrite_registration method instead.

This method will not register type dependencies. Use register to register a type with its dependencies.

Returns true if the registration was added and false if it already exists.

pub fn overwrite_registration(&mut self, registration: TypeRegistration)

Registers the type described by registration.

If the registration for the type already exists, it will be overwritten.

To avoid overwriting existing registrations, it’s recommended to use the register or add_registration methods instead.

This method will not register type dependencies. Use register to register a type with its dependencies.

pub fn register_type_data<T, D>(&mut self)

where T: Reflect + TypePath, D: TypeData + FromType<T>,

Registers the type data D for type T.

Most of the time TypeRegistry::register can be used instead to register a type you derived Reflect for. However, in cases where you want to add a piece of type data that was not included in the list of #[reflect(...)] type data in the derive, or where the type is generic and cannot register e.g. ReflectSerialize unconditionally without knowing the specific type parameters, this method can be used to insert additional type data.

Example

use bevy_reflect::{TypeRegistry, ReflectSerialize, ReflectDeserialize};

let mut type_registry = TypeRegistry::default();
type_registry.register::<Option<String>>();
type_registry.register_type_data::<Option<String>, ReflectSerialize>();
type_registry.register_type_data::<Option<String>, ReflectDeserialize>();

pub fn contains(&self, type_id: TypeId) -> bool

pub fn get(&self, type_id: TypeId) -> Option<&TypeRegistration>

Returns a reference to the TypeRegistration of the type with the given TypeId.

If the specified type has not been registered, returns None.

Examples found in repository

examples/reflection/generic_reflection.rs (line 25)

fn setup(type_registry: Res<AppTypeRegistry>) {
    let type_registry = type_registry.read();

    let registration = type_registry.get(TypeId::of::<MyType<u32>>()).unwrap();
    info!(
        "Registration for {} exists",
        registration.type_info().type_path(),
    );

    // MyType<String> was not manually registered, so it does not exist
    assert!(type_registry.get(TypeId::of::<MyType<String>>()).is_none());
}

pub fn get_mut(&mut self, type_id: TypeId) -> Option<&mut TypeRegistration>

Returns a mutable reference to the TypeRegistration of the type with the given TypeId.

If the specified type has not been registered, returns None.

pub fn get_with_type_path(&self, type_path: &str) -> Option<&TypeRegistration>

Returns a reference to the TypeRegistration of the type with the given type path.

If no type with the given path has been registered, returns None.

pub fn get_with_type_path_mut( &mut self, type_path: &str ) -> Option<&mut TypeRegistration>

Returns a mutable reference to the TypeRegistration of the type with the given type path.

If no type with the given type path has been registered, returns None.

pub fn get_with_short_type_path( &self, short_type_path: &str ) -> Option<&TypeRegistration>

Returns a reference to the TypeRegistration of the type with the given short type path.

If the short type path is ambiguous, or if no type with the given path has been registered, returns None.

pub fn get_with_short_type_path_mut( &mut self, short_type_path: &str ) -> Option<&mut TypeRegistration>

Returns a mutable reference to the TypeRegistration of the type with the given short type path.

If the short type path is ambiguous, or if no type with the given path has been registered, returns None.

pub fn is_ambiguous(&self, short_type_path: &str) -> bool

Returns true if the given short type path is ambiguous, that is, it matches multiple registered types.

Example

let mut type_registry = TypeRegistry::default();
type_registry.register::<foo::MyType>();
type_registry.register::<bar::MyType>();
assert_eq!(type_registry.is_ambiguous("MyType"), true);

pub fn get_type_data<T>(&self, type_id: TypeId) -> Option<&T>

where T: TypeData,

Returns a reference to the TypeData of type T associated with the given TypeId.

The returned value may be used to downcast Reflect trait objects to trait objects of the trait used to generate T, provided that the underlying reflected type has the proper #[reflect(DoThing)] attribute.

If the specified type has not been registered, or if T is not present in its type registration, returns None.

Examples found in repository

examples/reflection/trait_reflection.rs (line 48)

fn setup(type_registry: Res<AppTypeRegistry>) {
    // First, lets box our type as a Box<dyn Reflect>
    let reflect_value: Box<dyn Reflect> = Box::new(MyType {
        value: "Hello".to_string(),
    });

    // This means we no longer have direct access to MyType or its methods. We can only call Reflect
    // methods on reflect_value. What if we want to call `do_thing` on our type? We could
    // downcast using reflect_value.downcast_ref::<MyType>(), but what if we don't know the type
    // at compile time?

    // Normally in rust we would be out of luck at this point. Lets use our new reflection powers to
    // do something cool!
    let type_registry = type_registry.read();

    // The #[reflect] attribute we put on our DoThing trait generated a new `ReflectDoThing` struct,
    // which implements TypeData. This was added to MyType's TypeRegistration.
    let reflect_do_thing = type_registry
        .get_type_data::<ReflectDoThing>(reflect_value.type_id())
        .unwrap();

    // We can use this generated type to convert our `&dyn Reflect` reference to a `&dyn DoThing`
    // reference
    let my_trait: &dyn DoThing = reflect_do_thing.get(&*reflect_value).unwrap();

    // Which means we can now call do_thing(). Magic!
    info!("{}", my_trait.do_thing());

    // This works because the #[reflect(MyTrait)] we put on MyType informed the Reflect derive to
    // insert a new instance of ReflectDoThing into MyType's registration. The instance knows
    // how to cast &dyn Reflect to &dyn MyType, because it knows that &dyn Reflect should first
    // be downcasted to &MyType, which can then be safely casted to &dyn MyType
}

pub fn get_type_data_mut<T>(&mut self, type_id: TypeId) -> Option<&mut T>

where T: TypeData,

Returns a mutable reference to the TypeData of type T associated with the given TypeId.

If the specified type has not been registered, or if T is not present in its type registration, returns None.

pub fn get_type_info(&self, type_id: TypeId) -> Option<&'static TypeInfo>

Returns the TypeInfo associated with the given TypeId.

If the specified type has not been registered, returns None.

pub fn iter(&self) -> impl Iterator<Item = &TypeRegistration>

Returns an iterator over the TypeRegistrations of the registered types.

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut TypeRegistration>

Returns a mutable iterator over the TypeRegistrations of the registered types.

pub fn iter_with_data<T>(&self) -> impl Iterator<Item = (&TypeRegistration, &T)>

where T: TypeData,

Checks to see if the TypeData of type T is associated with each registered type, returning a (TypeRegistration, TypeData) iterator for all entries where data of that type was found.

Trait Implementations

impl Default for TypeRegistry

fn default() -> TypeRegistry

Returns the “default value” for a type.