Trait amethyst::ecs::join::ParJoin

pub unsafe trait ParJoin: Join {
    fn par_join(self) -> JoinParIter<Self> { ... }
}

The purpose of the ParJoin trait is to provide a way to access multiple storages in parallel at the same time with the merged bit set.

Provided Methods

fn par_join(self) -> JoinParIter<Self>

Create a joined parallel iterator over the contents.

Implementations on Foreign Types

impl<A, B> ParJoin for BitSetAnd<A, B> where     A: BitSetLike,     B: BitSetLike,

fn par_join(self) -> JoinParIter<Self>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> ParJoin for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where     A: ParJoin,     B: ParJoin,     C: ParJoin,     D: ParJoin,     E: ParJoin,     F: ParJoin,     G: ParJoin,     H: ParJoin,     I: ParJoin,     J: ParJoin,     K: ParJoin,     L: ParJoin,     M: ParJoin,     N: ParJoin,     O: ParJoin,     P: ParJoin,     (<A as Join>::Mask, <B as Join>::Mask, <C as Join>::Mask, <D as Join>::Mask, <E as Join>::Mask, <F as Join>::Mask, <G as Join>::Mask, <H as Join>::Mask, <I as Join>::Mask, <J as Join>::Mask, <K as Join>::Mask, <L as Join>::Mask, <M as Join>::Mask, <N as Join>::Mask, <O as Join>::Mask, <P as Join>::Mask): BitAnd,

fn par_join(self) -> JoinParIter<Self>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M> ParJoin for (A, B, C, D, E, F, G, H, I, J, K, L, M) where     A: ParJoin,     B: ParJoin,     C: ParJoin,     D: ParJoin,     E: ParJoin,     F: ParJoin,     G: ParJoin,     H: ParJoin,     I: ParJoin,     J: ParJoin,     K: ParJoin,     L: ParJoin,     M: ParJoin,     (<A as Join>::Mask, <B as Join>::Mask, <C as Join>::Mask, <D as Join>::Mask, <E as Join>::Mask, <F as Join>::Mask, <G as Join>::Mask, <H as Join>::Mask, <I as Join>::Mask, <J as Join>::Mask, <K as Join>::Mask, <L as Join>::Mask, <M as Join>::Mask): BitAnd,

fn par_join(self) -> JoinParIter<Self>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> ParJoin for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) where     A: ParJoin,     B: ParJoin,     C: ParJoin,     D: ParJoin,     E: ParJoin,     F: ParJoin,     G: ParJoin,     H: ParJoin,     I: ParJoin,     J: ParJoin,     K: ParJoin,     L: ParJoin,     M: ParJoin,     N: ParJoin,     O: ParJoin,     P: ParJoin,     Q: ParJoin,     R: ParJoin,     (<A as Join>::Mask, <B as Join>::Mask, <C as Join>::Mask, <D as Join>::Mask, <E as Join>::Mask, <F as Join>::Mask, <G as Join>::Mask, <H as Join>::Mask, <I as Join>::Mask, <J as Join>::Mask, <K as Join>::Mask, <L as Join>::Mask, <M as Join>::Mask, <N as Join>::Mask, <O as Join>::Mask, <P as Join>::Mask, <Q as Join>::Mask, <R as Join>::Mask): BitAnd,

fn par_join(self) -> JoinParIter<Self>

impl<A> ParJoin for (A,) where     A: ParJoin,     (<A as Join>::Mask,): BitAnd,

fn par_join(self) -> JoinParIter<Self>

impl<A, B> ParJoin for BitSetOr<A, B> where     A: BitSetLike,     B: BitSetLike,

fn par_join(self) -> JoinParIter<Self>

impl ParJoin for AtomicBitSet

fn par_join(self) -> JoinParIter<Self>

impl<'a, A> ParJoin for &'a BitSetNot<A> where     A: BitSetLike,

fn par_join(self) -> JoinParIter<Self>

impl<A, B, C, D, E, F, G, H, I> ParJoin for (A, B, C, D, E, F, G, H, I) where     A: ParJoin,     B: ParJoin,     C: ParJoin,     D: ParJoin,     E: ParJoin,     F: ParJoin,     G: ParJoin,     H: ParJoin,     I: ParJoin,     (<A as Join>::Mask, <B as Join>::Mask, <C as Join>::Mask, <D as Join>::Mask, <E as Join>::Mask, <F as Join>::Mask, <G as Join>::Mask, <H as Join>::Mask, <I as Join>::Mask): BitAnd,

fn par_join(self) -> JoinParIter<Self>

impl<'a, A, B> ParJoin for &'a BitSetAnd<A, B> where     A: BitSetLike,     B: BitSetLike,

fn par_join(self) -> JoinParIter<Self>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> ParJoin for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where     A: ParJoin,     B: ParJoin,     C: ParJoin,     D: ParJoin,     E: ParJoin,     F: ParJoin,     G: ParJoin,     H: ParJoin,     I: ParJoin,     J: ParJoin,     K: ParJoin,     L: ParJoin,     M: ParJoin,     N: ParJoin,     O: ParJoin,     P: ParJoin,     Q: ParJoin,     (<A as Join>::Mask, <B as Join>::Mask, <C as Join>::Mask, <D as Join>::Mask, <E as Join>::Mask, <F as Join>::Mask, <G as Join>::Mask, <H as Join>::Mask, <I as Join>::Mask, <J as Join>::Mask, <K as Join>::Mask, <L as Join>::Mask, <M as Join>::Mask, <N as Join>::Mask, <O as Join>::Mask, <P as Join>::Mask, <Q as Join>::Mask): BitAnd,

fn par_join(self) -> JoinParIter<Self>

impl<A, B, C, D, E, F> ParJoin for (A, B, C, D, E, F) where     A: ParJoin,     B: ParJoin,     C: ParJoin,     D: ParJoin,     E: ParJoin,     F: ParJoin,     (<A as Join>::Mask, <B as Join>::Mask, <C as Join>::Mask, <D as Join>::Mask, <E as Join>::Mask, <F as Join>::Mask): BitAnd,

fn par_join(self) -> JoinParIter<Self>

impl<A, B, C, D, E> ParJoin for (A, B, C, D, E) where     A: ParJoin,     B: ParJoin,     C: ParJoin,     D: ParJoin,     E: ParJoin,     (<A as Join>::Mask, <B as Join>::Mask, <C as Join>::Mask, <D as Join>::Mask, <E as Join>::Mask): BitAnd,

fn par_join(self) -> JoinParIter<Self>

impl<A, B, C, D, E, F, G, H> ParJoin for (A, B, C, D, E, F, G, H) where     A: ParJoin,     B: ParJoin,     C: ParJoin,     D: ParJoin,     E: ParJoin,     F: ParJoin,     G: ParJoin,     H: ParJoin,     (<A as Join>::Mask, <B as Join>::Mask, <C as Join>::Mask, <D as Join>::Mask, <E as Join>::Mask, <F as Join>::Mask, <G as Join>::Mask, <H as Join>::Mask): BitAnd,

fn par_join(self) -> JoinParIter<Self>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N> ParJoin for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where     A: ParJoin,     B: ParJoin,     C: ParJoin,     D: ParJoin,     E: ParJoin,     F: ParJoin,     G: ParJoin,     H: ParJoin,     I: ParJoin,     J: ParJoin,     K: ParJoin,     L: ParJoin,     M: ParJoin,     N: ParJoin,     (<A as Join>::Mask, <B as Join>::Mask, <C as Join>::Mask, <D as Join>::Mask, <E as Join>::Mask, <F as Join>::Mask, <G as Join>::Mask, <H as Join>::Mask, <I as Join>::Mask, <J as Join>::Mask, <K as Join>::Mask, <L as Join>::Mask, <M as Join>::Mask, <N as Join>::Mask): BitAnd,

fn par_join(self) -> JoinParIter<Self>

impl<A, B, C, D, E, F, G, H, I, J, K> ParJoin for (A, B, C, D, E, F, G, H, I, J, K) where     A: ParJoin,     B: ParJoin,     C: ParJoin,     D: ParJoin,     E: ParJoin,     F: ParJoin,     G: ParJoin,     H: ParJoin,     I: ParJoin,     J: ParJoin,     K: ParJoin,     (<A as Join>::Mask, <B as Join>::Mask, <C as Join>::Mask, <D as Join>::Mask, <E as Join>::Mask, <F as Join>::Mask, <G as Join>::Mask, <H as Join>::Mask, <I as Join>::Mask, <J as Join>::Mask, <K as Join>::Mask): BitAnd,

fn par_join(self) -> JoinParIter<Self>

impl<A> ParJoin for BitSetNot<A> where     A: BitSetLike,

fn par_join(self) -> JoinParIter<Self>

impl<'a> ParJoin for &'a AtomicBitSet

fn par_join(self) -> JoinParIter<Self>

impl<A, B, C, D, E, F, G> ParJoin for (A, B, C, D, E, F, G) where     A: ParJoin,     B: ParJoin,     C: ParJoin,     D: ParJoin,     E: ParJoin,     F: ParJoin,     G: ParJoin,     (<A as Join>::Mask, <B as Join>::Mask, <C as Join>::Mask, <D as Join>::Mask, <E as Join>::Mask, <F as Join>::Mask, <G as Join>::Mask): BitAnd,

fn par_join(self) -> JoinParIter<Self>

impl<A, B> ParJoin for BitSetXor<A, B> where     A: BitSetLike,     B: BitSetLike,

fn par_join(self) -> JoinParIter<Self>

impl<'a, A, B> ParJoin for &'a BitSetOr<A, B> where     A: BitSetLike,     B: BitSetLike,

fn par_join(self) -> JoinParIter<Self>

impl<A, B, C> ParJoin for (A, B, C) where     A: ParJoin,     B: ParJoin,     C: ParJoin,     (<A as Join>::Mask, <B as Join>::Mask, <C as Join>::Mask): BitAnd,

fn par_join(self) -> JoinParIter<Self>

impl<A, B, C, D> ParJoin for (A, B, C, D) where     A: ParJoin,     B: ParJoin,     C: ParJoin,     D: ParJoin,     (<A as Join>::Mask, <B as Join>::Mask, <C as Join>::Mask, <D as Join>::Mask): BitAnd,

fn par_join(self) -> JoinParIter<Self>

impl<A, B> ParJoin for (A, B) where     A: ParJoin,     B: ParJoin,     (<A as Join>::Mask, <B as Join>::Mask): BitAnd,

fn par_join(self) -> JoinParIter<Self>

impl<A, B, C, D, E, F, G, H, I, J> ParJoin for (A, B, C, D, E, F, G, H, I, J) where     A: ParJoin,     B: ParJoin,     C: ParJoin,     D: ParJoin,     E: ParJoin,     F: ParJoin,     G: ParJoin,     H: ParJoin,     I: ParJoin,     J: ParJoin,     (<A as Join>::Mask, <B as Join>::Mask, <C as Join>::Mask, <D as Join>::Mask, <E as Join>::Mask, <F as Join>::Mask, <G as Join>::Mask, <H as Join>::Mask, <I as Join>::Mask, <J as Join>::Mask): BitAnd,

fn par_join(self) -> JoinParIter<Self>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> ParJoin for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where     A: ParJoin,     B: ParJoin,     C: ParJoin,     D: ParJoin,     E: ParJoin,     F: ParJoin,     G: ParJoin,     H: ParJoin,     I: ParJoin,     J: ParJoin,     K: ParJoin,     L: ParJoin,     M: ParJoin,     N: ParJoin,     O: ParJoin,     (<A as Join>::Mask, <B as Join>::Mask, <C as Join>::Mask, <D as Join>::Mask, <E as Join>::Mask, <F as Join>::Mask, <G as Join>::Mask, <H as Join>::Mask, <I as Join>::Mask, <J as Join>::Mask, <K as Join>::Mask, <L as Join>::Mask, <M as Join>::Mask, <N as Join>::Mask, <O as Join>::Mask): BitAnd,

fn par_join(self) -> JoinParIter<Self>

impl<A, B, C, D, E, F, G, H, I, J, K, L> ParJoin for (A, B, C, D, E, F, G, H, I, J, K, L) where     A: ParJoin,     B: ParJoin,     C: ParJoin,     D: ParJoin,     E: ParJoin,     F: ParJoin,     G: ParJoin,     H: ParJoin,     I: ParJoin,     J: ParJoin,     K: ParJoin,     L: ParJoin,     (<A as Join>::Mask, <B as Join>::Mask, <C as Join>::Mask, <D as Join>::Mask, <E as Join>::Mask, <F as Join>::Mask, <G as Join>::Mask, <H as Join>::Mask, <I as Join>::Mask, <J as Join>::Mask, <K as Join>::Mask, <L as Join>::Mask): BitAnd,

fn par_join(self) -> JoinParIter<Self>

Implementors

• impl<'rf, 'st, C, S, B, Restrict> ParJoin for &'rf RestrictedStorage<'rf, 'st, C, S, B, Restrict> where     'st: 'rf,     B: Borrow<BitSet> + 'rf,     C: Component,     Restrict: ImmutableAliasing,     S: Borrow<<C as Component>::Storage> + 'rf,

• impl<'a, 'e, T, D> ParJoin for &'a Storage<'e, T, D> where     D: Deref<Target = MaskedStorage<T>>,     T: Component,     <T as Component>::Storage: Sync,

• impl<'a> ParJoin for AntiStorage<'a>

• impl ParJoin for BitSet

• impl<'a> ParJoin for &'a EntitiesRes

• impl<'rf, 'st, C, S, B> ParJoin for &'rf mut RestrictedStorage<'rf, 'st, C, S, B, MutableParallelRestriction> where     'st: 'rf,     B: Borrow<BitSet> + 'rf,     C: Component,     S: BorrowMut<<C as Component>::Storage> + 'rf,

• impl<'a> ParJoin for &'a BitSet

• impl<'a, 'e, T, D> ParJoin for &'a mut Storage<'e, T, D> where     D: DerefMut<Target = MaskedStorage<T>>,     T: Component,     <T as Component>::Storage: Sync,     <T as Component>::Storage: DistinctStorage,