Trait async_ecs::join::ParJoin

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

Provided methods

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

Loading content...

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, 

Loading content...

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, 

Loading content...