Trait specs::Join

pub trait Join {
    type Type;
    type Value;
    type Mask: BitSetLike;
    fn open(self) -> (Self::Mask, Self::Value);
    unsafe fn get(&mut Self::Value, Index) -> Self::Type;

    fn iter(self) -> JoinIter<Self> where Self: Sized { ... }
}

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

Associated Types

type Type

Type of joined components.

type Value

Type of joined storages.

type Mask: BitSetLike

Type of joined bit mask.

Required Methods

fn open(self) -> (Self::Mask, Self::Value)

Open this join by returning the mask and the storages.

unsafe fn get(&mut Self::Value, Index) -> Self::Type

Get a joined component value by a gien index.

Provided Methods

fn iter(self) -> JoinIter<Self> where Self: Sized

Create a joined iterator over the contents.

Implementors

• impl<'a> Join for AntiStorage<'a>
• impl<'a, T, A, D> Join for &'a Storage<T, A, D> where T: Component,
        A: Deref<Target=Allocator>,
        D: Deref<Target=MaskedStorage<T>>
• impl<'a, T, A, D> Join for &'a mut Storage<T, A, D> where T: Component,
        A: Deref<Target=Allocator>,
        D: DerefMut<Target=MaskedStorage<T>>
• impl<'a> Join for &'a Entities<'a>
• impl<'a, A> Join for (A,) where A: Join, (A::Mask,): BitAnd
• impl<'a, A, B> Join for (A, B) where A: Join, B: Join, (A::Mask, B::Mask): BitAnd
• impl<'a, A, B, C> Join for (A, B, C) where A: Join, B: Join, C: Join, (A::Mask, B::Mask, C::Mask): BitAnd
• impl<'a, A, B, C, D> Join for (A, B, C, D) where A: Join,
        B: Join,
        C: Join,
        D: Join,
        (A::Mask, B::Mask, C::Mask, D::Mask): BitAnd
• impl<'a, A, B, C, D, E> Join for (A, B, C, D, E) where A: Join,
        B: Join,
        C: Join,
        D: Join,
        E: Join,
        (A::Mask, B::Mask, C::Mask, D::Mask, E::Mask): BitAnd
• impl<'a, A, B, C, D, E, F> Join for (A, B, C, D, E, F) where A: Join,
        B: Join,
        C: Join,
        D: Join,
        E: Join,
        F: Join,
        (A::Mask, B::Mask, C::Mask, D::Mask, E::Mask, F::Mask): BitAnd
• impl<'a, A, B, C, D, E, F, G> Join for (A, B, C, D, E, F, G) where A: Join,
        B: Join,
        C: Join,
        D: Join,
        E: Join,
        F: Join,
        G: Join,
        (A::Mask, B::Mask, C::Mask, D::Mask, E::Mask, F::Mask, G::Mask): BitAnd
• impl<'a, A, B, C, D, E, F, G, H> Join for (A, B, C, D, E, F, G, H) where A: Join,
        B: Join,
        C: Join,
        D: Join,
        E: Join,
        F: Join,
        G: Join,
        H: Join,
        (A::Mask, B::Mask, C::Mask, D::Mask, E::Mask, F::Mask, G::Mask, H::Mask): BitAnd
• impl<'a, A, B, C, D, E, F, G, H, I> Join for (A, B, C, D, E, F, G, H, I) where A: Join,
        B: Join,
        C: Join,
        D: Join,
        E: Join,
        F: Join,
        G: Join,
        H: Join,
        I: Join,
        (A::Mask, B::Mask, C::Mask, D::Mask, E::Mask, F::Mask, G::Mask, H::Mask, I::Mask): BitAnd
• impl<'a, A, B, C, D, E, F, G, H, I, J> Join for (A, B, C, D, E, F, G, H, I, J) where A: Join,
        B: Join,
        C: Join,
        D: Join,
        E: Join,
        F: Join,
        G: Join,
        H: Join,
        I: Join,
        J: Join,
        (A::Mask, B::Mask, C::Mask, D::Mask, E::Mask, F::Mask, G::Mask, H::Mask, I::Mask, J::Mask): BitAnd
• impl<'a, A, B, C, D, E, F, G, H, I, J, K> Join for (A, B, C, D, E, F, G, H, I, J, K) where A: Join,
        B: Join,
        C: Join,
        D: Join,
        E: Join,
        F: Join,
        G: Join,
        H: Join,
        I: Join,
        J: Join,
        K: Join,
        (A::Mask, B::Mask, C::Mask, D::Mask, E::Mask, F::Mask, G::Mask, H::Mask, I::Mask, J::Mask, K::Mask): BitAnd
• impl<'a, A, B, C, D, E, F, G, H, I, J, K, L> Join for (A, B, C, D, E, F, G, H, I, J, K, L) where A: Join,
        B: Join,
        C: Join,
        D: Join,
        E: Join,
        F: Join,
        G: Join,
        H: Join,
        I: Join,
        J: Join,
        K: Join,
        L: Join,
        (A::Mask, B::Mask, C::Mask, D::Mask, E::Mask, F::Mask, G::Mask, H::Mask, I::Mask, J::Mask, K::Mask, L::Mask): BitAnd
• impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M> Join for (A, B, C, D, E, F, G, H, I, J, K, L, M) where A: Join,
        B: Join,
        C: Join,
        D: Join,
        E: Join,
        F: Join,
        G: Join,
        H: Join,
        I: Join,
        J: Join,
        K: Join,
        L: Join,
        M: Join,
        (A::Mask, B::Mask, C::Mask, D::Mask, E::Mask, F::Mask, G::Mask, H::Mask, I::Mask, J::Mask, K::Mask, L::Mask, M::Mask): BitAnd
• impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N> Join for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where A: Join,
        B: Join,
        C: Join,
        D: Join,
        E: Join,
        F: Join,
        G: Join,
        H: Join,
        I: Join,
        J: Join,
        K: Join,
        L: Join,
        M: Join,
        N: Join,
        (A::Mask, B::Mask, C::Mask, D::Mask, E::Mask, F::Mask, G::Mask, H::Mask, I::Mask, J::Mask, K::Mask, L::Mask, M::Mask, N::Mask): BitAnd
• impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Join for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where A: Join,
        B: Join,
        C: Join,
        D: Join,
        E: Join,
        F: Join,
        G: Join,
        H: Join,
        I: Join,
        J: Join,
        K: Join,
        L: Join,
        M: Join,
        N: Join,
        O: Join,
        (A::Mask, B::Mask, C::Mask, D::Mask, E::Mask, F::Mask, G::Mask, H::Mask, I::Mask, J::Mask, K::Mask, L::Mask, M::Mask, N::Mask, O::Mask): BitAnd
• impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Join for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where A: Join,
        B: Join,
        C: Join,
        D: Join,
        E: Join,
        F: Join,
        G: Join,
        H: Join,
        I: Join,
        J: Join,
        K: Join,
        L: Join,
        M: Join,
        N: Join,
        O: Join,
        P: Join,
        (A::Mask, B::Mask, C::Mask, D::Mask, E::Mask, F::Mask, G::Mask, H::Mask, I::Mask, J::Mask, K::Mask, L::Mask, M::Mask, N::Mask, O::Mask, P::Mask): BitAnd