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

source

pub fn empty() -> Self

Create a type registry with no registered types.

source

pub fn new() -> Self

Create a type registry with default registrations for primitive types.

source

pub fn register<T>(&mut self)

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());
source

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.

source

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.

source

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>();
source

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

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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);
source

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.

source

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.

source

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.

source

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

Returns an iterator over the TypeRegistrations of the registered types.

source

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

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

source

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§

source§

impl Default for TypeRegistry

source§

fn default() -> Self

Returns the “default value” for a type. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> Downcast for T
where T: Any,

source§

fn into_any(self: Box<T>) -> Box<dyn Any>

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

Convert 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)

Convert &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)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
source§

impl<T> DowncastSync for T
where T: Any + Send + Sync,

source§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T> Instrument for T

source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<T> WithSubscriber for T

source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

impl<T> ConditionalSend for T
where T: Send,