Struct shipyard::iterators::NonPacked7

pub struct NonPacked7<A: IntoAbstract, B: IntoAbstract, C: IntoAbstract, D: IntoAbstract, E: IntoAbstract, F: IntoAbstract, G: IntoAbstract> { /* fields omitted */ }

Non packed iterator over 7 components.

Trait Implementations

impl<A: IntoAbstract, B: IntoAbstract, C: IntoAbstract, D: IntoAbstract, E: IntoAbstract, F: IntoAbstract, G: IntoAbstract> CurrentId for NonPacked7<A, B, C, D, E, F, G>

type Id = EntityId

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

Safety

impl<A: IntoAbstract, B: IntoAbstract, C: IntoAbstract, D: IntoAbstract, E: IntoAbstract, F: IntoAbstract, G: IntoAbstract> From<NonPacked7<A, B, C, D, E, F, G>> for ParNonPacked7<A, B, C, D, E, F, G>

fn from(seq: NonPacked7<A, B, C, D, E, F, G>) -> Self

Performs the conversion.

impl<A: IntoAbstract, B: IntoAbstract, C: IntoAbstract, D: IntoAbstract, E: IntoAbstract, F: IntoAbstract, G: IntoAbstract> From<Update7<A, B, C, D, E, F, G>> for NonPacked7<A, B, C, D, E, F, G>

fn from(update: Update7<A, B, C, D, E, F, G>) -> Self

Performs the conversion.

impl<A: IntoAbstract, B: IntoAbstract, C: IntoAbstract, D: IntoAbstract, E: IntoAbstract, F: IntoAbstract, G: IntoAbstract> IntoIterator for NonPacked7<A, B, C, D, E, F, G>

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<A: IntoAbstract, B: IntoAbstract, C: IntoAbstract, D: IntoAbstract, E: IntoAbstract, F: IntoAbstract, G: IntoAbstract> Shiperator for NonPacked7<A, B, C, D, E, F, G>

type Item = (<A::AbsView as AbstractMut>::Out, <B::AbsView as AbstractMut>::Out, <C::AbsView as AbstractMut>::Out, <D::AbsView as AbstractMut>::Out, <E::AbsView as AbstractMut>::Out, <F::AbsView as AbstractMut>::Out, <G::AbsView as AbstractMut>::Out)

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.

impl<A: IntoAbstract, B: IntoAbstract, C: IntoAbstract, D: IntoAbstract, E: IntoAbstract, F: IntoAbstract, G: IntoAbstract> UnindexedProducer for NonPacked7<A, B, C, D, E, F, G> where
    A::AbsView: Clone + Send,
    B::AbsView: Clone + Send,
    C::AbsView: Clone + Send,
    D::AbsView: Clone + Send,
    E::AbsView: Clone + Send,
    F::AbsView: Clone + Send,
    G::AbsView: Clone + Send,
    <A::AbsView as AbstractMut>::Out: Send,
    <B::AbsView as AbstractMut>::Out: Send,
    <C::AbsView as AbstractMut>::Out: Send,
    <D::AbsView as AbstractMut>::Out: Send,
    <E::AbsView as AbstractMut>::Out: Send,
    <F::AbsView as AbstractMut>::Out: Send,
    <G::AbsView as AbstractMut>::Out: Send, 

type Item = (<A::AbsView as AbstractMut>::Out, <B::AbsView as AbstractMut>::Out, <C::AbsView as AbstractMut>::Out, <D::AbsView as AbstractMut>::Out, <E::AbsView as AbstractMut>::Out, <F::AbsView as AbstractMut>::Out, <G::AbsView as AbstractMut>::Out)

The type of item returned by this producer.

fn split(self) -> (Self, Option<Self>)

Split midway into a new producer if possible, otherwise return None.

fn fold_with<Fold>(self, folder: Fold) -> Fold where
    Fold: Folder<Self::Item>, 

Iterate the producer, feeding each element to folder, and stop when the folder is full (or all elements have been consumed).

impl<A: IntoAbstract, B: IntoAbstract, C: IntoAbstract, D: IntoAbstract, E: IntoAbstract, F: IntoAbstract, G: IntoAbstract> Send for NonPacked7<A, B, C, D, E, F, G> where
    A::AbsView: Clone + Send,
    B::AbsView: Clone + Send,
    C::AbsView: Clone + Send,
    D::AbsView: Clone + Send,
    E::AbsView: Clone + Send,
    F::AbsView: Clone + Send,
    G::AbsView: Clone + Send,
    <A::AbsView as AbstractMut>::Out: Send,
    <B::AbsView as AbstractMut>::Out: Send,
    <C::AbsView as AbstractMut>::Out: Send,
    <D::AbsView as AbstractMut>::Out: Send,
    <E::AbsView as AbstractMut>::Out: Send,
    <F::AbsView as AbstractMut>::Out: Send,
    <G::AbsView as AbstractMut>::Out: Send,