Struct shipyard::iterators::Loose9

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

Loose iterator over 9 components.

Trait Implementations

impl<A: IntoAbstract, B: IntoAbstract, C: IntoAbstract, D: IntoAbstract, E: IntoAbstract, F: IntoAbstract, G: IntoAbstract, H: IntoAbstract, I: IntoAbstract> CurrentId for Loose9<A, B, C, D, E, F, G, H, I>

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, H: IntoAbstract, I: IntoAbstract> ExactSizeShiperator for Loose9<A, B, C, D, E, F, G, H, I>

fn len(&self) -> usize

Returns the number of components this shiperator will yield.

impl<A: IntoAbstract, B: IntoAbstract, C: IntoAbstract, D: IntoAbstract, E: IntoAbstract, F: IntoAbstract, G: IntoAbstract, H: IntoAbstract, I: IntoAbstract> From<Loose9<A, B, C, D, E, F, G, H, I>> for ParLoose9<A, B, C, D, E, F, G, H, I>

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

Performs the conversion.

impl<A: IntoAbstract, B: IntoAbstract, C: IntoAbstract, D: IntoAbstract, E: IntoAbstract, F: IntoAbstract, G: IntoAbstract, H: IntoAbstract, I: IntoAbstract> IntoIterator for Loose9<A, B, C, D, E, F, G, H, 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<A: IntoAbstract, B: IntoAbstract, C: IntoAbstract, D: IntoAbstract, E: IntoAbstract, F: IntoAbstract, G: IntoAbstract, H: IntoAbstract, I: IntoAbstract> Producer for Loose9<A, B, C, D, E, F, G, H, I> 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,
    H::AbsView: Clone + Send,
    I::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,
    <H::AbsView as AbstractMut>::Out: Send,
    <I::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, <H::AbsView as AbstractMut>::Out, <I::AbsView as AbstractMut>::Out)

The type of item that will be produced by this producer once it is converted into an iterator.

type IntoIter = IntoIterator<Self>

The type of iterator we will become.

fn into_iter(self) -> Self::IntoIter

Convert self into an iterator; at this point, no more parallel splits are possible.

fn split_at(self, index: usize) -> (Self, Self)

Split into two producers; one produces items 0..index, the other index..N. Index must be less than or equal to N.

fn min_len(&self) -> usize

The minimum number of items that we will process sequentially. Defaults to 1, which means that we will split all the way down to a single item. This can be raised higher using the with_min_len method, which will force us to create sequential tasks at a larger granularity. Note that Rayon automatically normally attempts to adjust the size of parallel splits to reduce overhead, so this should not be needed.

fn max_len(&self) -> usize

The maximum number of items that we will process sequentially. Defaults to MAX, which means that we can choose not to split at all. This can be lowered using the with_max_len method, which will force us to create more parallel tasks. Note that Rayon automatically normally attempts to adjust the size of parallel splits to reduce overhead, so this should not be needed.

fn fold_with<F>(self, folder: F) -> F where
    F: 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, H: IntoAbstract, I: IntoAbstract> Shiperator for Loose9<A, B, C, D, E, F, G, H, I>

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, <H::AbsView as AbstractMut>::Out, <I::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, H: IntoAbstract, I: IntoAbstract> Send for Loose9<A, B, C, D, E, F, G, H, I> 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,
    H::AbsView: Clone + Send,
    I::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,
    <H::AbsView as AbstractMut>::Out: Send,
    <I::AbsView as AbstractMut>::Out: Send,