Struct ContiguousComponentTicksRef 

pub struct ContiguousComponentTicksRef<'w> { /* private fields */ }

Data type storing contiguously lying ticks.

Retrievable via ContiguousRef::split and probably only useful if you want to use the following methods:

• ContiguousComponentTicksRef::is_changed_iter,
• ContiguousComponentTicksRef::is_added_iter

Implementations

impl<'w> ContiguousComponentTicksRef<'w>

pub fn new( added: &'w [Tick], changed: &'w [Tick], summary_tick: Option<&'w AtomicTick>, last_run: Tick, this_run: Tick, caller: MaybeLocation<&'w [&'static Location<'static>]>, ) -> Option<Self>

Creates a new ContiguousComponentTicksRef using provided values or returns None if lengths of added, changed and changed_by do not match

This is an advanced feature, ContiguousComponentTicksRefs are designed to be created by engine-internal code and consumed by end-user code.

• added - Ticks that store the tick when the wrapped value was created.
• changed - Ticks that store the last time the wrapped value was changed.
• last_run - A Tick, occurring before this_run, which is used as a reference to determine whether the wrapped value is newly added or changed.
• this_run - A Tick corresponding to the current point in time – “now”.
• caller - Locations that store the location when the wrapper value was changed.

pub fn added(&self) -> &'w [Tick]

Returns added ticks’ slice.

pub fn changed(&self) -> &'w [Tick]

Returns changed ticks’ slice.

pub fn changed_by(&self) -> MaybeLocation<&[&'static Location<'static>]>

Returns changed by locations’ slice.

pub fn last_run(&self) -> Tick

Returns the tick the system last ran.

pub fn this_run(&self) -> Tick

Returns the tick of the current system’s run.

pub fn is_changed_iter(&self) -> impl Iterator<Item = bool>

Returns an iterator where the i-th item corresponds to whether the i-th component was marked as changed. If the value equals true, then the component was changed.

Example

fn some_system(mut query: Query<Ref<A>>) {
    for a in query.contiguous_iter().unwrap() {
        let (a_values, a_ticks) = ContiguousRef::split(a);
        for (value, is_changed) in a_values.iter().zip(a_ticks.is_changed_iter()) {
            if is_changed {
                // do something
            }
        }
    }
}

pub fn is_added_iter(&self) -> impl Iterator<Item = bool>

Returns an iterator where the i-th item corresponds to whether the i-th component was marked as added. If the value equals true, then the component was added.

Example

fn some_system(mut query: Query<Ref<A>>) {
    for a in query.contiguous_iter().unwrap() {
        let (a_values, a_ticks) = ContiguousRef::split(a);
        for (value, is_added) in a_values.iter().zip(a_ticks.is_added_iter()) {
            if is_added {
                // do something
            }
        }
    }
}

pub fn slice(self, range: Range<u32>) -> Self

Narrows the range of rows that this set of ticks represents.

If the range is out of range, this method will panic.

pub fn summary_tick_is_changed(&self) -> Option<bool>

Returns Some(true) if this component has a summary tick and any component in this column may have been changed since the last time the associated query ran.

If the component has no summary tick, this method returns None. If there is a summary tick, but there has been no change since the last time the query ran, this method returns Some(false).

Trait Implementations

impl<'w> Clone for ContiguousComponentTicksRef<'w>

fn clone(&self) -> ContiguousComponentTicksRef<'w>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'w> From<ContiguousComponentTicksMut<'w>> for ContiguousComponentTicksRef<'w>

fn from(value: ContiguousComponentTicksMut<'w>) -> Self

Converts to this type from the input type.