Struct BehaviorMutItem

pub struct BehaviorMutItem<'__w, T: Behavior> { /* private fields */ }

Automatically generated WorldQuery item type for BehaviorMut, returned when iterating over query results.

Implementations

impl<T: Behavior> BehaviorMutItem<'_, T>

pub fn current(&self) -> &T

Returns the current Behavior state.

pub fn current_mut(&mut self) -> &mut T

Returns the current Behavior state as a mutable.

pub fn previous(&self) -> Option<&T>

See BehaviorRefItem::previous.

pub fn previous_mut(&mut self) -> Option<&mut T>

Returns the previous Behavior state as a mutable.

See BehaviorRefItem::previous for more details.

pub fn iter(&self) -> impl Iterator<Item = &T> + '_

See BehaviorRefItem::iter.

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> + '_

Returns a mutable iterator over all Behavior states in the stack, including the current one.

See BehaviorRefItem::iter for more details.

pub fn index(&self) -> BehaviorIndex

See BehaviorRefItem::index.

pub fn has_index(&self, index: BehaviorIndex) -> bool

See BehaviorRefItem::has_index.

pub fn has_transition(&self) -> bool

See BehaviorRefItem::has_transition.

pub fn has_sequence(&self) -> bool

See BehaviorRefItem::has_sequence.

pub fn start(&mut self, next: T)

Starts the given next behavior.

This operation pushes the current behavior onto the stack and inserts the new behavior.

Note that this will fail if the current behavior rejects next through Behavior::filter_next. See Error for details on how to handle transition failures.

pub fn try_start(&mut self, next: T) -> Result<(), T>

Attempts to start the given next behavior if there are no pending transitions and the current behavior allows it.

Note that it’s still possible for the transition to fail if the current behavior mutates in such a way as to no longer allow the transition between the time this function is called and when the transition system runs.

Do NOT use this method to react to transition failures. See Error for details on how to correctly handle transition failures.

Usage

This is similar to start but will return an error containing the given next behavior if it fails.

This is useful for fire-and-forget transitions where you don’t want to override a pending transition or may expect a transition failure.

If multiple systems call this method before transition, only the first one will succeed.

pub fn interrupt_start(&mut self, next: T)

Interrupts the current behavior and starts the given next behavior.

This operation stops all behaviors which yield to the new behavior and pushes it onto the stack. See Behavior::filter_yield for details on how to define how states yield to each other.

This also removes any remaining TransitionSequence steps.

The initial behavior is never allowed to yield.

Note that this will fail if the first non-yielding behavior rejects next through Behavior::filter_next. See Error for details on how to handle transition failures.

pub fn try_interrupt_start(&mut self, next: T) -> Result<(), T>

Attempts to interrupt the current behavior and start the given next behavior.

This is similar to interrupt_start but will fail if there is a pending transition.

pub fn interrupt_stop(&mut self, index: BehaviorIndex)

Stops all behaviors above and including the given BehaviorIndex.

This also removes any remaining TransitionSequence steps.

The initial behavior is never allowed to yield.

pub fn try_interrupt_stop( &mut self, index: BehaviorIndex, ) -> Result<(), BehaviorIndex>

Attempts to stop all behaviors above and including the given BehaviorIndex.

This is similar to interrupt_stop but will fail if:

• There is a pending transition
• The given index is the initial behavior
• The given index is not in the stack

pub fn interrupt_resume(&mut self, index: BehaviorIndex)

Stops all behaviors above the given BehaviorIndex and resume the behavior at that index.

This also removes any remaining TransitionSequence steps.

pub fn try_interrupt_resume( &mut self, index: BehaviorIndex, ) -> Result<(), BehaviorIndex>

Attempts to stop all behaviors above the given BehaviorIndex and resume the behavior at that index.

This is similar to interrupt_resume but will fail if:

• There is a pending transition
• The given index is not in the stack

pub fn stop(&mut self)

Stops the current behavior.

This operation pops the current behavior off the stack and resumes the previous behavior.

Note that this will fail if the current behavior is the initial behavior. See Error for details on how to handle transition failures.

pub fn try_stop(&mut self) -> bool

Attempts to stop the current behavior.

This is similar to stop but will fail if:

• There is a pending transition
• The current behavior is the initial behavior

pub fn reset(&mut self)

Stops the current and all previous behaviors and resumes the initial behavior.

This operation clears the stack and resumes the initial behavior. It can never fail. If the stack is empty (i.e. initial behavior), it does nothing.

pub fn try_reset(&mut self) -> bool

Attempts to reset the current behavior.

This is similar to reset but will fail if there is a pending transition.

Trait Implementations

impl<T: Behavior> AsMut<T> for BehaviorMutItem<'_, T>

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

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T: Behavior> AsRef<T> for BehaviorMutItem<'_, T>

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Behavior> Deref for BehaviorMutItem<'_, T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Behavior> DerefMut for BehaviorMutItem<'_, T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: Behavior> DetectChanges for BehaviorMutItem<'_, T>

fn is_added(&self) -> bool

Returns true if this value was added after the system last ran.

fn is_changed(&self) -> bool

Returns true if this value was added or mutably dereferenced either since the last time the system ran or, if the system never ran, since the beginning of the program.

fn last_changed(&self) -> Tick

Returns the change tick recording the time this data was most recently changed.

fn added(&self) -> Tick

Returns the change tick recording the time this data was added.

fn changed_by(&self) -> MaybeLocation

The location that last caused this to change.

impl<T: Behavior> DetectChangesMut for BehaviorMutItem<'_, T>

type Inner = T

The type contained within this smart pointer

fn set_changed(&mut self)

Flags this value as having been changed.

fn set_last_changed(&mut self, last_changed: Tick)

Manually sets the change tick recording the time when this data was last mutated.

fn bypass_change_detection(&mut self) -> &mut Self::Inner

Manually bypasses change detection, allowing you to mutate the underlying value without updating the change tick.

fn set_added(&mut self)

Flags this value as having been added.

fn set_last_added(&mut self, last_added: Tick)

Manually sets the added tick recording the time when this data was last added.

fn set_if_neq(&mut self, value: Self::Inner) -> bool

where Self::Inner: Sized + PartialEq,

Overwrites this smart pointer with the given value, if and only if *self != value. Returns true if the value was overwritten, and returns false if it was not.

fn replace_if_neq(&mut self, value: Self::Inner) -> Option<Self::Inner>

where Self::Inner: Sized + PartialEq,

Overwrites this smart pointer with the given value, if and only if *self != value, returning the previous value if this occurs.

fn clone_from_if_neq<T>(&mut self, value: &T) -> bool

where T: ToOwned<Owned = Self::Inner> + ?Sized, Self::Inner: PartialEq<T>,

Overwrites this smart pointer with a clone of the given value, if and only if *self != value. Returns true if the value was overwritten, and returns false if it was not.

impl<T: Behavior> Index<BehaviorIndex> for BehaviorMutItem<'_, T>

type Output = T

The returned type after indexing.

fn index(&self, BehaviorIndex: BehaviorIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T: Behavior> IndexMut<BehaviorIndex> for BehaviorMutItem<'_, T>

fn index_mut(&mut self, BehaviorIndex: BehaviorIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.