Struct shipyard::WithId

pub struct WithId<I> { /* fields omitted */ }

Shiperator yielding EntityId as well.

Trait Implementations

impl<I: CurrentId> CurrentId for WithId<I>

type Id = I::Id

unsafe fn current_id(&self) -> Self::Id

Safety

impl<I: CurrentId> IntoIterator for WithId<I>

type IntoIter = IntoIterator<Self>

Which kind of iterator are we turning this into?

type Item = <Self as Shiperator>::Item

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<I: CurrentId> Shiperator for WithId<I>

type Item = (I::Id, I::Item)

fn first_pass(&mut self) -> Option<Self::Item>

fn post_process(&mut self)

fn size_hint(&self) -> (usize, Option<usize>)

Returns the minimum number of components yielded and maybe the maximum.

fn next(&mut self) -> Option<Self::Item>

Returns the next component.

fn for_each<F>(self, f: F) where
    Self: Sized,
    F: FnMut(Self::Item), 

Visits all components and apply f.

fn try_for_each<F, E>(&mut self, f: F) -> Result<(), E> where
    Self: Sized,
    F: FnMut(Self::Item) -> Result<(), E>, 

Visits all components and apply f, can return early.

fn fold<Acc, F>(self, acc: Acc, f: F) -> Acc where
    Self: Sized,
    F: FnMut(Acc, Self::Item) -> Acc, 

Visits all components, apply f and store the result in acc.

fn try_fold<Acc, F, E>(&mut self, acc: Acc, f: F) -> Result<Acc, E> where
    Self: Sized,
    F: FnMut(Acc, Self::Item) -> Result<Acc, E>, 

Visits all components, apply f and store the result in acc, can return early.

fn enumerate(self) -> Enumerate<Self> where
    Self: Sized, 

Returns the current iteration count as well as component(s).

fn with_id(self) -> WithId<Self> where
    Self: Sized + CurrentId, 

Returns EntityId as well as component(s).

fn filter<P>(self, pred: P) -> Filter<Self, P> where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool, 

Skips components that doesn’t match pred.

fn count(self) -> usize where
    Self: Sized, 

Consumes the shiperator and counts the number of iterations.

fn map<R, F>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Item) -> R, 

Applies f to all visited components.
Using it on an update packed storages will flag entities even if they’re not yielded at the end.

fn find<P>(&mut self, pred: P) -> Option<Self::Item> where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool, 

Searches component(s) that matches pred.

fn into_iterator(self) -> IntoIterator<Self> where
    Self: Sized, 

Transforms a shiperator into an iterator, allowing the use of for loop and crates such as itertools.
Iterator doesn’t know about update pack so it’ll flag everything it visits.

fn collect<C: FromIterator<Self::Item>>(self) -> C where
    Self: Sized, 

Collects this shiperator into a collection.