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: Component<Mutability = Mutable>> EntityEntryCommands<'a, T>

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

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

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

pub fn or_insert(&mut self, default: T) -> &mut Self

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

pub fn or_try_insert(&mut self, default: T) -> &mut Self

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 Self

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 Self

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 Self

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 Self

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"));
}