Trait ParJoin 

pub trait ParJoin: Join {
    // Provided method
    fn par_join(self) -> JoinParIter<Self>
       where Self: Sized { ... }
}

Provided Methods

fn par_join(self) -> JoinParIter<Self>

where Self: Sized,

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<A> ParJoin for (A,)

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

impl<A, B> ParJoin for (A, B)

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

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

Implementors

impl<'a> ParJoin for &'a Entities

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

impl<'a, 'b, T> ParJoin for &'a Read<'b, T>

where &'a T: ParJoin, T: Resource,

impl<'a, 'b, T> ParJoin for &'a Ref<'b, T>

where &'a T: ParJoin, T: Resource,

impl<'a, 'b, T> ParJoin for &'a mut Write<'b, T>

where &'a mut T: ParJoin, T: Resource,

impl<'a, 'b, T> ParJoin for &'a mut RefMut<'b, T>

where &'a mut T: ParJoin, T: Resource,

impl<'a, 'e, T, D> ParJoin for &'a StorageWrapper<'e, T, D>

where T: Component, D: Deref<Target = MaskedStorage<T>>, T::Storage: Sync,

impl<'a, 'e, T, D> ParJoin for &'a mut StorageWrapper<'e, T, D>

where T: Component, D: DerefMut<Target = MaskedStorage<T>>, T::Storage: Sync + DistinctStorage,

impl<T> ParJoin for MaybeJoin<T>

where T: ParJoin,