Trait specs::Join

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

    fn join(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(value: &mut Self::Value, id: Index) -> Self::Type

Get a joined component value by a given index.

Provided Methods

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

Create a joined iterator over the contents.

Implementations on Foreign Types

impl<'a, A> Join for (A,) where
    A: Join,
    (<A as Join>::Mask,): BitAnd, 

type Type = (A::Type,)

type Value = (A::Value,)

type Mask = <(A::Mask,) as BitAnd>::Value

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

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

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

impl<'a, A, B> Join for (A, B) where
    A: Join,
    B: Join,
    (<A as Join>::Mask, <B as Join>::Mask): BitAnd, 

type Type = (A::Type, B::Type)

type Value = (A::Value, B::Value)

type Mask = <(A::Mask, B::Mask) as BitAnd>::Value

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

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

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

impl<'a, A, B, C> Join for (A, B, C) where
    A: Join,
    B: Join,
    C: Join,
    (<A as Join>::Mask, <B as Join>::Mask, <C as Join>::Mask): BitAnd, 

type Type = (A::Type, B::Type, C::Type)

type Value = (A::Value, B::Value, C::Value)

type Mask = <(A::Mask, B::Mask, C::Mask) as BitAnd>::Value

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

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

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

impl<'a, A, B, C, D> Join for (A, B, C, D) where
    A: Join,
    B: Join,
    C: Join,
    D: Join,
    (<A as Join>::Mask, <B as Join>::Mask, <C as Join>::Mask, <D as Join>::Mask): BitAnd, 

type Type = (A::Type, B::Type, C::Type, D::Type)

type Value = (A::Value, B::Value, C::Value, D::Value)

type Mask = <(A::Mask, B::Mask, C::Mask, D::Mask) as BitAnd>::Value

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

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

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

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 as Join>::Mask, <B as Join>::Mask, <C as Join>::Mask, <D as Join>::Mask, <E as Join>::Mask): BitAnd, 

type Type = (A::Type, B::Type, C::Type, D::Type, E::Type)

type Value = (A::Value, B::Value, C::Value, D::Value, E::Value)

type Mask = <(A::Mask, B::Mask, C::Mask, D::Mask, E::Mask) as BitAnd>::Value

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

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

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

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 as Join>::Mask, <B as Join>::Mask, <C as Join>::Mask, <D as Join>::Mask, <E as Join>::Mask, <F as Join>::Mask): BitAnd, 

type Type = (A::Type, B::Type, C::Type, D::Type, E::Type, F::Type)

type Value = (A::Value, B::Value, C::Value, D::Value, E::Value, F::Value)

type Mask = <(A::Mask, B::Mask, C::Mask, D::Mask, E::Mask, F::Mask) as BitAnd>::Value

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

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

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

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 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, 

type Type = (A::Type, B::Type, C::Type, D::Type, E::Type, F::Type, G::Type)

type Value = (A::Value, B::Value, C::Value, D::Value, E::Value, F::Value, G::Value)

type Mask = <(A::Mask, B::Mask, C::Mask, D::Mask, E::Mask, F::Mask, G::Mask) as BitAnd>::Value

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

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

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

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 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, 

type Type = (A::Type, B::Type, C::Type, D::Type, E::Type, F::Type, G::Type, H::Type)

type Value = (A::Value, B::Value, C::Value, D::Value, E::Value, F::Value, G::Value, H::Value)

type Mask = <(A::Mask, B::Mask, C::Mask, D::Mask, E::Mask, F::Mask, G::Mask, H::Mask) as BitAnd>::Value

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

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

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

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 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, 

type Type = (A::Type, B::Type, C::Type, D::Type, E::Type, F::Type, G::Type, H::Type, I::Type)

type Value = (A::Value, B::Value, C::Value, D::Value, E::Value, F::Value, G::Value, H::Value, I::Value)

type Mask = <(A::Mask, B::Mask, C::Mask, D::Mask, E::Mask, F::Mask, G::Mask, H::Mask, I::Mask) as BitAnd>::Value

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

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

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

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 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, 

type Type = (A::Type, B::Type, C::Type, D::Type, E::Type, F::Type, G::Type, H::Type, I::Type, J::Type)

type Value = (A::Value, B::Value, C::Value, D::Value, E::Value, F::Value, G::Value, H::Value, I::Value, J::Value)

type Mask = <(A::Mask, B::Mask, C::Mask, D::Mask, E::Mask, F::Mask, G::Mask, H::Mask, I::Mask, J::Mask) as BitAnd>::Value

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

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

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

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 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, 

type Type = (A::Type, B::Type, C::Type, D::Type, E::Type, F::Type, G::Type, H::Type, I::Type, J::Type, K::Type)

type Value = (A::Value, B::Value, C::Value, D::Value, E::Value, F::Value, G::Value, H::Value, I::Value, J::Value, K::Value)

type Mask = <(A::Mask, B::Mask, C::Mask, D::Mask, E::Mask, F::Mask, G::Mask, H::Mask, I::Mask, J::Mask, K::Mask) as BitAnd>::Value

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

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

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

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 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, 

type Type = (A::Type, B::Type, C::Type, D::Type, E::Type, F::Type, G::Type, H::Type, I::Type, J::Type, K::Type, L::Type)

type Value = (A::Value, B::Value, C::Value, D::Value, E::Value, F::Value, G::Value, H::Value, I::Value, J::Value, K::Value, L::Value)

type Mask = <(A::Mask, B::Mask, C::Mask, D::Mask, E::Mask, F::Mask, G::Mask, H::Mask, I::Mask, J::Mask, K::Mask, L::Mask) as BitAnd>::Value

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

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

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

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 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, 

type Type = (A::Type, B::Type, C::Type, D::Type, E::Type, F::Type, G::Type, H::Type, I::Type, J::Type, K::Type, L::Type, M::Type)

type Value = (A::Value, B::Value, C::Value, D::Value, E::Value, F::Value, G::Value, H::Value, I::Value, J::Value, K::Value, L::Value, M::Value)

type Mask = <(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) as BitAnd>::Value

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

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

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

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 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, 

type Type = (A::Type, B::Type, C::Type, D::Type, E::Type, F::Type, G::Type, H::Type, I::Type, J::Type, K::Type, L::Type, M::Type, N::Type)

type Value = (A::Value, B::Value, C::Value, D::Value, E::Value, F::Value, G::Value, H::Value, I::Value, J::Value, K::Value, L::Value, M::Value, N::Value)

type Mask = <(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) as BitAnd>::Value

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

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

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

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 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, 

type Type = (A::Type, B::Type, C::Type, D::Type, E::Type, F::Type, G::Type, H::Type, I::Type, J::Type, K::Type, L::Type, M::Type, N::Type, O::Type)

type Value = (A::Value, B::Value, C::Value, D::Value, E::Value, F::Value, G::Value, H::Value, I::Value, J::Value, K::Value, L::Value, M::Value, N::Value, O::Value)

type Mask = <(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) as BitAnd>::Value

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

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

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

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 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, 

type Type = (A::Type, B::Type, C::Type, D::Type, E::Type, F::Type, G::Type, H::Type, I::Type, J::Type, K::Type, L::Type, M::Type, N::Type, O::Type, P::Type)

type Value = (A::Value, B::Value, C::Value, D::Value, E::Value, F::Value, G::Value, H::Value, I::Value, J::Value, K::Value, L::Value, M::Value, N::Value, O::Value, P::Value)

type Mask = <(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) as BitAnd>::Value

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

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

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

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> Join for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) 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,
    Q: Join,
    (<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, 

type Type = (A::Type, B::Type, C::Type, D::Type, E::Type, F::Type, G::Type, H::Type, I::Type, J::Type, K::Type, L::Type, M::Type, N::Type, O::Type, P::Type, Q::Type)

type Value = (A::Value, B::Value, C::Value, D::Value, E::Value, F::Value, G::Value, H::Value, I::Value, J::Value, K::Value, L::Value, M::Value, N::Value, O::Value, P::Value, Q::Value)

type Mask = <(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, Q::Mask) as BitAnd>::Value

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

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

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

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> Join for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) 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,
    Q: Join,
    R: Join,
    (<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, 

type Type = (A::Type, B::Type, C::Type, D::Type, E::Type, F::Type, G::Type, H::Type, I::Type, J::Type, K::Type, L::Type, M::Type, N::Type, O::Type, P::Type, Q::Type, R::Type)

type Value = (A::Value, B::Value, C::Value, D::Value, E::Value, F::Value, G::Value, H::Value, I::Value, J::Value, K::Value, L::Value, M::Value, N::Value, O::Value, P::Value, Q::Value, R::Value)

type Mask = <(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, Q::Mask, R::Mask) as BitAnd>::Value

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

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

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

Implementors

• impl<'a, 'e, T, D> Join for &'a CheckStorage<'e, T, D> type Type = Entry<'a, 'e, T, D>; type Value = *const Storage<'e, T, D>; type Mask = &'a BitSet;
• impl<'a, C, T: UnprotectedStorage<C>> Join for &'a FlaggedStorage<C, T> type Type = &'a C; type Value = &'a T; type Mask = &'a BitSet;
• impl<'a, C, T: UnprotectedStorage<C>> Join for &'a mut FlaggedStorage<C, T> type Type = &'a mut C; type Value = &'a mut T; type Mask = &'a BitSet;
• impl<'a, 'e, T, D> Join for &'a Storage<'e, T, D> where
    T: Component,
    D: Deref<Target = MaskedStorage<T>>,  type Type = &'a T; type Value = &'a T::Storage; type Mask = &'a BitSet;
• impl<'a, 'e, T, D> Join for &'a mut Storage<'e, T, D> where
    T: Component,
    D: DerefMut<Target = MaskedStorage<T>>,  type Type = &'a mut T; type Value = &'a mut T::Storage; type Mask = &'a BitSet;
• impl<'a> Join for &'a EntitiesRes type Type = Entity; type Value = Self; type Mask = BitSetOr<&'a BitSet, &'a AtomicBitSet>;