Struct bevy_reflect::TypeRegistry
source · pub struct TypeRegistry { /* private fields */ }
Expand description
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§
source§impl TypeRegistry
impl TypeRegistry
sourcepub fn register<T>(&mut self)where
T: GetTypeRegistration,
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());
sourcepub fn add_registration(&mut self, registration: TypeRegistration) -> bool
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.
sourcepub fn overwrite_registration(&mut self, registration: TypeRegistration)
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.
sourcepub fn register_type_data<T: Reflect + TypePath, D: TypeData + FromType<T>>(
&mut self
)
pub fn register_type_data<T: Reflect + TypePath, 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 contains(&self, type_id: TypeId) -> bool
sourcepub fn get(&self, type_id: TypeId) -> Option<&TypeRegistration>
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
.
sourcepub fn get_mut(&mut self, type_id: TypeId) -> Option<&mut TypeRegistration>
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
.
sourcepub fn get_with_type_path(&self, type_path: &str) -> Option<&TypeRegistration>
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
.
sourcepub fn get_with_type_path_mut(
&mut self,
type_path: &str
) -> Option<&mut TypeRegistration>
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
.
sourcepub fn get_with_short_type_path(
&self,
short_type_path: &str
) -> Option<&TypeRegistration>
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
.
sourcepub fn get_with_short_type_path_mut(
&mut self,
short_type_path: &str
) -> Option<&mut TypeRegistration>
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
.
sourcepub fn is_ambiguous(&self, short_type_path: &str) -> bool
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);
sourcepub fn get_type_data<T: TypeData>(&self, type_id: TypeId) -> Option<&T>
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
.
sourcepub fn get_type_info(&self, type_id: TypeId) -> Option<&'static TypeInfo>
pub fn get_type_info(&self, type_id: TypeId) -> Option<&'static TypeInfo>
sourcepub fn iter(&self) -> impl Iterator<Item = &TypeRegistration>
pub fn iter(&self) -> impl Iterator<Item = &TypeRegistration>
Returns an iterator over the TypeRegistration
s of the registered
types.
sourcepub fn iter_mut(&mut self) -> impl Iterator<Item = &mut TypeRegistration>
pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut TypeRegistration>
Returns a mutable iterator over the TypeRegistration
s of the registered
types.
sourcepub fn iter_with_data<T: TypeData>(
&self
) -> impl Iterator<Item = (&TypeRegistration, &T)>
pub fn iter_with_data<T: TypeData>( &self ) -> impl Iterator<Item = (&TypeRegistration, &T)>
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§
Auto Trait Implementations§
impl Freeze for TypeRegistry
impl !RefUnwindSafe for TypeRegistry
impl Send for TypeRegistry
impl Sync for TypeRegistry
impl Unpin for TypeRegistry
impl !UnwindSafe for TypeRegistry
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
source§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
.source§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
.source§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s.source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s.