Skip to main content

ComponentHooks

bevy::ecs::lifecycle

Struct ComponentHooks 

Source 
pub struct ComponentHooks { /* private fields */ }
Expand description

World-mutating functions that run as part of lifecycle events of a Component.

Hooks are functions that run when a component is added, overwritten, or removed from an entity. These are intended to be used for structural side effects that need to happen when a component is added or removed, and are not intended for general-purpose logic.

For example, you might use a hook to update a cached index when a component is added, to clean up resources when a component is removed, or to keep hierarchical data structures across entities in sync.

This information is stored in the ComponentInfo of the associated component.

There are two ways of configuring hooks for a component:

  1. Defining the relevant hooks on the Component implementation
  2. Using the World::register_component_hooks method

§Example

use bevy_ecs::prelude::*;
use bevy_ecs::entity::EntityHashSet;

#[derive(Component)]
struct MyTrackedComponent;

#[derive(Resource, Default)]
struct TrackedEntities(EntityHashSet);

let mut world = World::new();
world.init_resource::<TrackedEntities>();

// No entities with `MyTrackedComponent` have been added yet, so we can safely add component hooks
let mut tracked_component_query = world.query::<&MyTrackedComponent>();
assert!(tracked_component_query.iter(&world).next().is_none());

world.register_component_hooks::<MyTrackedComponent>().on_add(|mut world, context| {
   let mut tracked_entities = world.resource_mut::<TrackedEntities>();
  tracked_entities.0.insert(context.entity);
});

world.register_component_hooks::<MyTrackedComponent>().on_remove(|mut world, context| {
  let mut tracked_entities = world.resource_mut::<TrackedEntities>();
  tracked_entities.0.remove(&context.entity);
});

let entity = world.spawn(MyTrackedComponent).id();
let tracked_entities = world.resource::<TrackedEntities>();
assert!(tracked_entities.0.contains(&entity));

world.despawn(entity);
let tracked_entities = world.resource::<TrackedEntities>();
assert!(!tracked_entities.0.contains(&entity));

Implementations§

Source§

impl ComponentHooks

Source

pub fn on_add( &mut self, hook: for<'w> fn(DeferredWorld<'w>, HookContext), ) -> &mut ComponentHooks

Register a ComponentHook that will be run when this component is added to an entity. An on_add hook will always run before on_insert hooks. Spawning an entity counts as adding all of its components.

§Panics

Will panic if the component already has an on_add hook

Examples found in repository?
examples/ecs/component_hooks.rs (lines 77-100)
61fn setup(world: &mut World) {
62    // In order to register component hooks the component must:
63    // - not be currently in use by any entities in the world
64    // - not already have a hook of that kind registered
65    // This is to prevent overriding hooks defined in plugins and other crates as well as keeping things fast
66    world
67        .register_component_hooks::<MyComponent>()
68        // There are 4 component lifecycle hooks: `on_add`, `on_insert`, `on_discard` and `on_remove`
69        // A hook has 2 arguments:
70        // - a `DeferredWorld`, this allows access to resource and component data as well as `Commands`
71        // - a `HookContext`, this provides access to the following contextual information:
72        //   - the entity that triggered the hook
73        //   - the component id of the triggering component, this is mostly used for dynamic components
74        //   - the location of the code that caused the hook to trigger
75        //
76        // `on_add` will trigger when a component is inserted onto an entity without it
77        .on_add(
78            |mut world,
79             HookContext {
80                 entity,
81                 component_id,
82                 caller,
83                 ..
84             }| {
85                // You can access component data from within the hook
86                let value = world.get::<MyComponent>(entity).unwrap().0;
87                println!(
88                    "{component_id:?} added to {entity} with value {value:?}{}",
89                    caller
90                        .map(|location| format!("due to {location}"))
91                        .unwrap_or_default()
92                );
93                // Or access resources
94                world
95                    .resource_mut::<MyComponentIndex>()
96                    .insert(value, entity);
97                // Or send messages
98                world.write_message(MyMessage);
99            },
100        )
101        // `on_insert` will trigger when a component is inserted onto an entity,
102        // regardless of whether or not it already had it and after `on_add` if it ran
103        .on_insert(|world, _| {
104            println!("Current Index: {:?}", world.resource::<MyComponentIndex>());
105        })
106        // `on_discard` will trigger when a component is inserted onto an entity that already had it,
107        // and runs before the value is replaced.
108        // Also triggers when a component is removed from an entity, and runs before `on_remove`
109        .on_discard(|mut world, context| {
110            let value = world.get::<MyComponent>(context.entity).unwrap().0;
111            world.resource_mut::<MyComponentIndex>().remove(&value);
112        })
113        // `on_remove` will trigger when a component is removed from an entity,
114        // since it runs before the component is removed you can still access the component data
115        .on_remove(
116            |mut world,
117             HookContext {
118                 entity,
119                 component_id,
120                 caller,
121                 ..
122             }| {
123                let value = world.get::<MyComponent>(entity).unwrap().0;
124                println!(
125                    "{component_id:?} removed from {entity} with value {value:?}{}",
126                    caller
127                        .map(|location| format!("due to {location}"))
128                        .unwrap_or_default()
129                );
130                // You can also issue commands through `.commands()`
131                world.commands().entity(entity).despawn();
132            },
133        );
134}
Source

pub fn on_insert( &mut self, hook: for<'w> fn(DeferredWorld<'w>, HookContext), ) -> &mut ComponentHooks

Register a ComponentHook that will be run when this component is added (with .insert) or replaced.

An on_insert hook always runs after any on_add hooks (if the entity didn’t already have the component).

§Warning

The hook won’t run if the component is already present and is only mutated, such as in a system via a query. As a result, this needs to be combined with immutable components to serve as a mechanism for reliably updating indexes and other caches.

§Panics

Will panic if the component already has an on_insert hook

Examples found in repository?
examples/ecs/component_hooks.rs (lines 103-105)
61fn setup(world: &mut World) {
62    // In order to register component hooks the component must:
63    // - not be currently in use by any entities in the world
64    // - not already have a hook of that kind registered
65    // This is to prevent overriding hooks defined in plugins and other crates as well as keeping things fast
66    world
67        .register_component_hooks::<MyComponent>()
68        // There are 4 component lifecycle hooks: `on_add`, `on_insert`, `on_discard` and `on_remove`
69        // A hook has 2 arguments:
70        // - a `DeferredWorld`, this allows access to resource and component data as well as `Commands`
71        // - a `HookContext`, this provides access to the following contextual information:
72        //   - the entity that triggered the hook
73        //   - the component id of the triggering component, this is mostly used for dynamic components
74        //   - the location of the code that caused the hook to trigger
75        //
76        // `on_add` will trigger when a component is inserted onto an entity without it
77        .on_add(
78            |mut world,
79             HookContext {
80                 entity,
81                 component_id,
82                 caller,
83                 ..
84             }| {
85                // You can access component data from within the hook
86                let value = world.get::<MyComponent>(entity).unwrap().0;
87                println!(
88                    "{component_id:?} added to {entity} with value {value:?}{}",
89                    caller
90                        .map(|location| format!("due to {location}"))
91                        .unwrap_or_default()
92                );
93                // Or access resources
94                world
95                    .resource_mut::<MyComponentIndex>()
96                    .insert(value, entity);
97                // Or send messages
98                world.write_message(MyMessage);
99            },
100        )
101        // `on_insert` will trigger when a component is inserted onto an entity,
102        // regardless of whether or not it already had it and after `on_add` if it ran
103        .on_insert(|world, _| {
104            println!("Current Index: {:?}", world.resource::<MyComponentIndex>());
105        })
106        // `on_discard` will trigger when a component is inserted onto an entity that already had it,
107        // and runs before the value is replaced.
108        // Also triggers when a component is removed from an entity, and runs before `on_remove`
109        .on_discard(|mut world, context| {
110            let value = world.get::<MyComponent>(context.entity).unwrap().0;
111            world.resource_mut::<MyComponentIndex>().remove(&value);
112        })
113        // `on_remove` will trigger when a component is removed from an entity,
114        // since it runs before the component is removed you can still access the component data
115        .on_remove(
116            |mut world,
117             HookContext {
118                 entity,
119                 component_id,
120                 caller,
121                 ..
122             }| {
123                let value = world.get::<MyComponent>(entity).unwrap().0;
124                println!(
125                    "{component_id:?} removed from {entity} with value {value:?}{}",
126                    caller
127                        .map(|location| format!("due to {location}"))
128                        .unwrap_or_default()
129                );
130                // You can also issue commands through `.commands()`
131                world.commands().entity(entity).despawn();
132            },
133        );
134}
Source

pub fn on_discard( &mut self, hook: for<'w> fn(DeferredWorld<'w>, HookContext), ) -> &mut ComponentHooks

Register a ComponentHook that will be run when this component is about to be dropped, such as being replaced (with .insert) or removed.

If this component is inserted onto an entity that already has it, this hook will run before the value is replaced, allowing access to the previous data just before it is dropped. This hook does not run if the entity did not already have this component.

An on_discard hook always runs before any on_remove hooks (if the component is being removed from the entity).

§Warning

The hook won’t run if the component is already present and is only mutated, such as in a system via a query. As a result, this needs to be combined with immutable components to serve as a mechanism for reliably updating indexes and other caches.

§Panics

Will panic if the component already has an on_discard hook

Examples found in repository?
examples/ecs/component_hooks.rs (lines 109-112)
61fn setup(world: &mut World) {
62    // In order to register component hooks the component must:
63    // - not be currently in use by any entities in the world
64    // - not already have a hook of that kind registered
65    // This is to prevent overriding hooks defined in plugins and other crates as well as keeping things fast
66    world
67        .register_component_hooks::<MyComponent>()
68        // There are 4 component lifecycle hooks: `on_add`, `on_insert`, `on_discard` and `on_remove`
69        // A hook has 2 arguments:
70        // - a `DeferredWorld`, this allows access to resource and component data as well as `Commands`
71        // - a `HookContext`, this provides access to the following contextual information:
72        //   - the entity that triggered the hook
73        //   - the component id of the triggering component, this is mostly used for dynamic components
74        //   - the location of the code that caused the hook to trigger
75        //
76        // `on_add` will trigger when a component is inserted onto an entity without it
77        .on_add(
78            |mut world,
79             HookContext {
80                 entity,
81                 component_id,
82                 caller,
83                 ..
84             }| {
85                // You can access component data from within the hook
86                let value = world.get::<MyComponent>(entity).unwrap().0;
87                println!(
88                    "{component_id:?} added to {entity} with value {value:?}{}",
89                    caller
90                        .map(|location| format!("due to {location}"))
91                        .unwrap_or_default()
92                );
93                // Or access resources
94                world
95                    .resource_mut::<MyComponentIndex>()
96                    .insert(value, entity);
97                // Or send messages
98                world.write_message(MyMessage);
99            },
100        )
101        // `on_insert` will trigger when a component is inserted onto an entity,
102        // regardless of whether or not it already had it and after `on_add` if it ran
103        .on_insert(|world, _| {
104            println!("Current Index: {:?}", world.resource::<MyComponentIndex>());
105        })
106        // `on_discard` will trigger when a component is inserted onto an entity that already had it,
107        // and runs before the value is replaced.
108        // Also triggers when a component is removed from an entity, and runs before `on_remove`
109        .on_discard(|mut world, context| {
110            let value = world.get::<MyComponent>(context.entity).unwrap().0;
111            world.resource_mut::<MyComponentIndex>().remove(&value);
112        })
113        // `on_remove` will trigger when a component is removed from an entity,
114        // since it runs before the component is removed you can still access the component data
115        .on_remove(
116            |mut world,
117             HookContext {
118                 entity,
119                 component_id,
120                 caller,
121                 ..
122             }| {
123                let value = world.get::<MyComponent>(entity).unwrap().0;
124                println!(
125                    "{component_id:?} removed from {entity} with value {value:?}{}",
126                    caller
127                        .map(|location| format!("due to {location}"))
128                        .unwrap_or_default()
129                );
130                // You can also issue commands through `.commands()`
131                world.commands().entity(entity).despawn();
132            },
133        );
134}
Source

pub fn on_remove( &mut self, hook: for<'w> fn(DeferredWorld<'w>, HookContext), ) -> &mut ComponentHooks

Register a ComponentHook that will be run when this component is removed from an entity. Despawning an entity counts as removing all of its components.

§Panics

Will panic if the component already has an on_remove hook

Examples found in repository?
examples/ecs/component_hooks.rs (lines 115-133)
61fn setup(world: &mut World) {
62    // In order to register component hooks the component must:
63    // - not be currently in use by any entities in the world
64    // - not already have a hook of that kind registered
65    // This is to prevent overriding hooks defined in plugins and other crates as well as keeping things fast
66    world
67        .register_component_hooks::<MyComponent>()
68        // There are 4 component lifecycle hooks: `on_add`, `on_insert`, `on_discard` and `on_remove`
69        // A hook has 2 arguments:
70        // - a `DeferredWorld`, this allows access to resource and component data as well as `Commands`
71        // - a `HookContext`, this provides access to the following contextual information:
72        //   - the entity that triggered the hook
73        //   - the component id of the triggering component, this is mostly used for dynamic components
74        //   - the location of the code that caused the hook to trigger
75        //
76        // `on_add` will trigger when a component is inserted onto an entity without it
77        .on_add(
78            |mut world,
79             HookContext {
80                 entity,
81                 component_id,
82                 caller,
83                 ..
84             }| {
85                // You can access component data from within the hook
86                let value = world.get::<MyComponent>(entity).unwrap().0;
87                println!(
88                    "{component_id:?} added to {entity} with value {value:?}{}",
89                    caller
90                        .map(|location| format!("due to {location}"))
91                        .unwrap_or_default()
92                );
93                // Or access resources
94                world
95                    .resource_mut::<MyComponentIndex>()
96                    .insert(value, entity);
97                // Or send messages
98                world.write_message(MyMessage);
99            },
100        )
101        // `on_insert` will trigger when a component is inserted onto an entity,
102        // regardless of whether or not it already had it and after `on_add` if it ran
103        .on_insert(|world, _| {
104            println!("Current Index: {:?}", world.resource::<MyComponentIndex>());
105        })
106        // `on_discard` will trigger when a component is inserted onto an entity that already had it,
107        // and runs before the value is replaced.
108        // Also triggers when a component is removed from an entity, and runs before `on_remove`
109        .on_discard(|mut world, context| {
110            let value = world.get::<MyComponent>(context.entity).unwrap().0;
111            world.resource_mut::<MyComponentIndex>().remove(&value);
112        })
113        // `on_remove` will trigger when a component is removed from an entity,
114        // since it runs before the component is removed you can still access the component data
115        .on_remove(
116            |mut world,
117             HookContext {
118                 entity,
119                 component_id,
120                 caller,
121                 ..
122             }| {
123                let value = world.get::<MyComponent>(entity).unwrap().0;
124                println!(
125                    "{component_id:?} removed from {entity} with value {value:?}{}",
126                    caller
127                        .map(|location| format!("due to {location}"))
128                        .unwrap_or_default()
129                );
130                // You can also issue commands through `.commands()`
131                world.commands().entity(entity).despawn();
132            },
133        );
134}
Source

pub fn on_despawn( &mut self, hook: for<'w> fn(DeferredWorld<'w>, HookContext), ) -> &mut ComponentHooks

Register a ComponentHook that will be run for each component on an entity when it is despawned.

§Panics

Will panic if the component already has an on_despawn hook

Source

pub fn try_on_add( &mut self, hook: for<'w> fn(DeferredWorld<'w>, HookContext), ) -> Option<&mut ComponentHooks>

Attempt to register a ComponentHook that will be run when this component is added to an entity.

This is a fallible version of Self::on_add.

Returns None if the component already has an on_add hook.

Source

pub fn try_on_insert( &mut self, hook: for<'w> fn(DeferredWorld<'w>, HookContext), ) -> Option<&mut ComponentHooks>

Attempt to register a ComponentHook that will be run when this component is added (with .insert)

This is a fallible version of Self::on_insert.

Returns None if the component already has an on_insert hook.

Source

pub fn try_on_discard( &mut self, hook: for<'w> fn(DeferredWorld<'w>, HookContext), ) -> Option<&mut ComponentHooks>

Attempt to register a ComponentHook that will be run when this component is replaced (with .insert) or removed

This is a fallible version of Self::on_discard.

Returns None if the component already has an on_discard hook.

Source

pub fn try_on_remove( &mut self, hook: for<'w> fn(DeferredWorld<'w>, HookContext), ) -> Option<&mut ComponentHooks>

Attempt to register a ComponentHook that will be run when this component is removed from an entity.

This is a fallible version of Self::on_remove.

Returns None if the component already has an on_remove hook.

Source

pub fn try_on_despawn( &mut self, hook: for<'w> fn(DeferredWorld<'w>, HookContext), ) -> Option<&mut ComponentHooks>

Attempt to register a ComponentHook that will be run for each component on an entity when it is despawned.

This is a fallible version of Self::on_despawn.

Returns None if the component already has an on_despawn hook.

Trait Implementations§

Source§

impl Clone for ComponentHooks

Source§

fn clone(&self) -> ComponentHooks

Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
Source§

impl Debug for ComponentHooks

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
Source§

impl Default for ComponentHooks

Source§

fn default() -> ComponentHooks

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, U> AsBindGroupShaderType<U> for T
where U: ShaderType, &'a T: for<'a> Into<U>,

Source§

fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U

Return the T ShaderType for self. When used in AsBindGroup derives, it is safe to assume that all images in self exist.
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<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
where ST: ?Sized, DT: ?Sized,

Source§

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
where ST: ?Sized, DT: ?Sized,

Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

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

Source§

impl<T> Conv for T

Source§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
Source§

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

Source§

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

Converts Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>, which can then be downcast into Box<dyn ConcreteType> where ConcreteType implements Trait.
Source§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Converts Rc<Trait> (where Trait: Downcast) to Rc<Any>, which can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
Source§

fn as_any(&self) -> &(dyn Any + 'static)

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

Converts &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> 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> DowncastSend for T
where T: Any + Send,

Source§

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

Converts Box<Trait> (where Trait: DowncastSend) to Box<dyn Any + Send>, which can then be downcast into Box<ConcreteType> where ConcreteType implements Trait.
Source§

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

Source§

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

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<S, T> Duplex<S> for T
where T: FromSample<S> + ToSample<S>,

Source§

impl<T> ErasedDestructor for T
where T: 'static,

Source§

impl<T> FmtForward for T

Source§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
Source§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
Source§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
Source§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
Source§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
Source§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
Source§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
Source§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
Source§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<S> FromSample<S> for S

Source§

fn from_sample_(s: S) -> S

Source§

impl<T> FromTemplate for T
where T: Clone + Default + Unpin,

Source§

type Template = T

The Template for this type.
Source§

impl<T> FromWorld for T
where T: Default,

Source§

fn from_world(_world: &mut World) -> T

Creates Self using default().

Source§

impl<T, W> HasTypeWitness<W> for T
where W: MakeTypeWitness<Arg = T>, T: ?Sized,

Source§

const WITNESS: W = W::MAKE

A constant of the type witness
Source§

impl<T> HitDataExtra for T
where T: Send + Sync + Debug + Any + 'static,

Source§

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

Source§

const TYPE_EQ: TypeEq<T, <T as Identity>::Type> = TypeEq::NEW

Proof that Self is the same type as Self::Type, provides methods for casting between Self and Self::Type.
Source§

type Type = T

The same type as Self, used to emulate type equality bounds (T == U) with associated type equality constraints (T: Identity<Type = U>).
Source§

impl<T> InitializeFromFunction<T> for T

Source§

fn initialize_from_function(f: fn() -> T) -> T

Create an instance of this type from an initialization function
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> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> IntoResult<T> for T

Source§

fn into_result(self) -> Result<T, RunSystemError>

Converts this type into the system output type.
Source§

impl<F, T> IntoSample<T> for F
where T: FromSample<F>,

Source§

fn into_sample(self) -> T

Source§

impl<A> Is for A
where A: Any,

Source§

fn is<T>() -> bool
where T: Any,

Checks if the current type “is” another type, using a TypeId equality comparison. This is most useful in the context of generic logic. Read more
Source§

impl<T> NoneValue for T
where T: Default,

Source§

type NoneType = T

Source§

fn null_value() -> T

The none-equivalent value.
Source§

impl<G> PatchFromTemplate for G
where G: FromTemplate,

Source§

type Template = <G as FromTemplate>::Template

The Template that will be patched.
Source§

fn patch<F>(func: F) -> TemplatePatch<F, <G as PatchFromTemplate>::Template>
where F: FnOnce(&mut <G as PatchFromTemplate>::Template, &mut ResolveContext<'_>),

Takes a “patch function” func, and turns it into a TemplatePatch.
Source§

impl<T> PatchTemplate for T
where T: Template,

Source§

fn patch_template<F>(func: F) -> TemplatePatch<F, T>
where F: FnOnce(&mut T, &mut ResolveContext<'_>),

Takes a “patch function” func that patches this Template, and turns it into a TemplatePatch.
Source§

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

Source§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
Source§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
Source§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
Source§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
Source§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
Source§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.
Source§

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.
Source§

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
Source§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
Source§

impl<T> Read<Exclusive, BecauseExclusive> for T
where T: ?Sized,

Source§

impl<R, P> ReadPrimitive<R> for P
where R: Read + ReadEndian<P>, P: Default,

Source§

fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_little_endian().
Source§

fn read_from_big_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_big_endian().
Source§

fn read_from_native_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_native_endian().
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T> Settings for T
where T: 'static + Send + Sync,

Source§

impl<Ret> SpawnIfAsync<(), Ret> for Ret

Source§

fn spawn(self) -> Ret

Spawn the value into the dioxus runtime if it is an async block
Source§

impl<T, O> SuperFrom<T> for O
where O: From<T>,

Source§

fn super_from(input: T) -> O

Convert from a type to another type.
Source§

impl<T, O, M> SuperInto<O, M> for T
where O: SuperFrom<T, M>,

Source§

fn super_into(self) -> O

Convert from a type to another type.
Source§

impl<T> Tap for T

Source§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
Source§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
Source§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
Source§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
Source§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
Source§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
Source§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
Source§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
Source§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
Source§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.
Source§

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.
Source§

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
Source§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
Source§

impl<T> Template for T
where T: Clone + Unpin,

Source§

type Output = T

The type of value produced by this Template.
Source§

fn build_template( &self, _context: &mut TemplateContext<'_, '_>, ) -> Result<<T as Template>::Output, BevyError>

Uses this template and the given entity context to produce a Template::Output.
Source§

fn clone_template(&self) -> T

Clones this template. See Clone.
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> ToSample<U> for T
where U: FromSample<T>,

Source§

fn to_sample_(self) -> U

Source§

impl<T> TryConv for T

Source§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
Source§

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

Source§

type Error = !

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

fn try_from(value: U) -> Result<T, !>

Performs the conversion.
Source§

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

Source§

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> TypeData for T
where T: 'static + Send + Sync + Clone,

Source§

fn clone_type_data(&self) -> Box<dyn TypeData>

Creates a type-erased clone of self.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

Source§

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

Source§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

Source§

impl<T> WasmNotSync for T
where T: Sync,

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