Struct EntityEntryCommands 

pub struct EntityEntryCommands<'a, T> { /* private fields */ }

A wrapper around EntityCommands with convenience methods for working with a specified component type.

Implementations

impl<'a, T> EntityEntryCommands<'a, T>

where T: Component<Mutability = Mutable>,

pub fn and_modify( &mut self, modify: impl FnOnce(Mut<'_, T>) + Send + Sync + 'static, ) -> &mut EntityEntryCommands<'a, T>

Modify the component T if it exists, using the function modify.

impl<'a, T> EntityEntryCommands<'a, T>

where T: Component,

pub fn reborrow(&mut self) -> EntityEntryCommands<'_, T>

Returns a EntityEntryCommands with a smaller lifetime.

This is useful if you have &mut EntityEntryCommands but need EntityEntryCommands.

pub fn or_insert(&mut self, default: T) -> &mut EntityEntryCommands<'a, T>

Insert default into this entity, if T is not already present.

pub fn or_try_insert(&mut self, default: T) -> &mut EntityEntryCommands<'a, T>

Insert default into this entity, if T is not already present.

Note

If the entity does not exist when this command is executed, the resulting error will be ignored.

pub fn or_insert_with<F>( &mut self, default: F, ) -> &mut EntityEntryCommands<'a, T>

where F: FnOnce() -> T + Send + 'static,

Insert the value returned from default into this entity, if T is not already present.

default will only be invoked if the component will actually be inserted.

pub fn or_try_insert_with<F>( &mut self, default: F, ) -> &mut EntityEntryCommands<'a, T>

where F: FnOnce() -> T + Send + 'static,

Insert the value returned from default into this entity, if T is not already present.

default will only be invoked if the component will actually be inserted.

Note

If the entity does not exist when this command is executed, the resulting error will be ignored.

pub fn or_default(&mut self) -> &mut EntityEntryCommands<'a, T>

where T: Default,

Insert T::default into this entity, if T is not already present.

T::default will only be invoked if the component will actually be inserted.

pub fn or_from_world(&mut self) -> &mut EntityEntryCommands<'a, T>

where T: FromWorld,

Insert T::from_world into this entity, if T is not already present.

T::from_world will only be invoked if the component will actually be inserted.

pub fn entity(&mut self) -> EntityCommands<'_>

Get the EntityCommands from which the EntityEntryCommands was initiated.

This allows you to continue chaining method calls after calling EntityCommands::entry.

Example

#[derive(Component)]
struct Level(u32);

fn level_up_system(mut commands: Commands, player: Res<PlayerEntity>) {
    commands
        .entity(player.entity)
        .entry::<Level>()
        // Modify the component if it exists.
        .and_modify(|mut lvl| lvl.0 += 1)
        // Otherwise, insert a default value.
        .or_insert(Level(0))
        // Return the EntityCommands for the entity.
        .entity()
        // Continue chaining method calls.
        .insert(Name::new("Player"));
}