Struct bevy_reflect::TypeRegistry

pub struct TypeRegistry { /* private fields */ }

A registry of reflected types.

Implementations

impl TypeRegistry

pub fn empty() -> Self

Create a type registry with no registered types.

pub fn new() -> Self

Create a type registry with default registrations for primitive types.

pub fn register<T>(&mut self)where
    T: GetTypeRegistration,

Registers the type T, adding reflect data as specified in the Reflect derive:

#[derive(Reflect)]
#[reflect(Component, Serialize, Deserialize)] // will register ReflectComponent, ReflectSerialize, ReflectDeserialize

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

Registers the type described by registration.

pub fn register_type_data<T: Reflect + 'static, D: TypeData + FromType<T>>(
    &mut self
)

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 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.

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_name(&self, type_name: &str) -> Option<&TypeRegistration>

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

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

pub fn get_with_name_mut(
    &mut self,
    type_name: &str
) -> Option<&mut TypeRegistration>

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

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

pub fn get_with_short_name(
    &self,
    short_type_name: &str
) -> Option<&TypeRegistration>

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

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

pub fn get_with_short_name_mut(
    &mut self,
    short_type_name: &str
) -> Option<&mut TypeRegistration>

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

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

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

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.

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

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.

Trait Implementations

impl Default for TypeRegistry

fn default() -> Self

Returns the “default value” for a type.