Trait specs::prelude::ParJoin

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

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.

Safety

The implementation of ParallelIterator for ParJoin makes multiple assumptions on the structure of Self. In particular, <Self as Join>::get must be callable from multiple threads, simultaneously, without mutating values not exclusively associated with id.

Provided Methods

fn par_join(self) -> JoinParIter<Self> where
    Self: Sized, 

Create a joined parallel iterator over the contents.

Implementations on Foreign Types

impl ParJoin for AtomicBitSet

impl<'a> ParJoin for &'a AtomicBitSet

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

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

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

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

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

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

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

impl<'a> ParJoin for &'a dyn BitSetLike

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, 

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, 

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, 

impl<'a, 'b, T> ParJoin for &'a Fetch<'b, T> where
    &'a T: ParJoin,
    T: Resource, 

impl<'a, 'b, T> ParJoin for &'a mut FetchMut<'b, T> where
    &'a mut T: ParJoin,
    T: Resource, 

Implementors

impl ParJoin for BitSet

impl<'a> ParJoin for &'a BitSet

impl<'a> ParJoin for &'a EntitiesRes

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 ReadExpect<'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 WriteExpect<'b, T> where
    &'a mut T: ParJoin,
    T: Resource, 

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

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

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

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

impl<T> ParJoin for MaybeJoin<T> where
    T: ParJoin,