[][src]Trait specs::join::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.

Loading content...

Implementations on Foreign Types

impl ParJoin for AtomicBitSet[src]

impl<'a> ParJoin for &'a AtomicBitSet[src]

impl<A> ParJoin for BitSetNot<A> where
    A: BitSetLike
[src]

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

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

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

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

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

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

impl<'a> ParJoin for &'a dyn BitSetLike[src]

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

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

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
[src]

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
[src]

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
[src]

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
[src]

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
[src]

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
[src]

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
[src]

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
[src]

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
[src]

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
[src]

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
[src]

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
[src]

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
[src]

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
[src]

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
[src]

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
[src]

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

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

Loading content...

Implementors

impl ParJoin for BitSet[src]

impl<'a> ParJoin for &'a BitSet[src]

impl<'a> ParJoin for &'a EntitiesRes[src]

impl<'a> ParJoin for AntiStorage<'a>[src]

impl<'a, 'b, T> ParJoin for &'a Read<'b, T> where
    &'a T: ParJoin,
    T: Resource
[src]

impl<'a, 'b, T> ParJoin for &'a ReadExpect<'b, T> where
    &'a T: ParJoin,
    T: Resource
[src]

impl<'a, 'b, T> ParJoin for &'a mut Write<'b, T> where
    &'a mut T: ParJoin,
    T: Resource
[src]

impl<'a, 'b, T> ParJoin for &'a mut WriteExpect<'b, T> where
    &'a mut T: ParJoin,
    T: Resource
[src]

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

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
[src]

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, 
[src]

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, 
[src]

impl<T> ParJoin for MaybeJoin<T> where
    T: ParJoin
[src]

Loading content...