Trait amethyst::ecs::join::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: u32) -> Self::Type;

    fn join(self) -> JoinIter<Self> { ... }
}

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

Joining component storages means that you'll only get values where for a given entity every storage has an associated component.

Example

let mut world = World::new();

world.register::<Pos>();
world.register::<Vel>();

{
    let pos = world.read_storage::<Pos>();
    let vel = world.read_storage::<Vel>();

    // There are no entities yet, so no pair will be returned.
    let joined: Vec<_> = (&pos, &vel).join().collect();
    assert_eq!(joined, vec![]);
}

world
    .create_entity()
    .with(Pos)
    .build();

{
    let pos = world.read_storage::<Pos>();
    let vel = world.read_storage::<Vel>();

    // Although there is an entity, it only has `Pos`.
    let joined: Vec<_> = (&pos, &vel).join().collect();
    assert_eq!(joined, vec![]);
}

let ent = world.create_entity()
    .with(Pos)
    .with(Vel)
    .build();

{
    let pos = world.read_storage::<Pos>();
    let vel = world.read_storage::<Vel>();

    // Now there is one entity that has both a `Vel` and a `Pos`.
    let joined: Vec<_> = (&pos, &vel).join().collect();
    assert_eq!(joined, vec![(&Pos, &Vel)]);

    // If we want to get the entity the components are associated to,
    // we need to join over `Entities`:

    let entities = world.read_resource::<EntitiesRes>();
    // note: `EntitiesRes` is the fetched resource; we get back
    // `Read<EntitiesRes>`.
    // `Read<EntitiesRes>` can also be referred to by `Entities` which
    // is a shorthand type definition to the former type.

    let joined: Vec<_> = (&*entities, &pos, &vel).join().collect(); // note the `&*entities`
    assert_eq!(joined, vec![(ent, &Pos, &Vel)]);
}

Iterating over a single storage

Join can also be used to iterate over a single storage, just by writing (&storage).join().

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: u32) -> Self::Type

Get a joined component value by a given index.

Provided Methods

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

Create a joined iterator over the contents.

Implementations on Foreign Types

impl<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 as Join>::Type, <B as Join>::Type, <C as Join>::Type, <D as Join>::Type, <E as Join>::Type, <F as Join>::Type, <G as Join>::Type, <H as Join>::Type, <I as Join>::Type, <J as Join>::Type, <K as Join>::Type, <L as Join>::Type, <M as Join>::Type, <N as Join>::Type, <O as Join>::Type, <P as Join>::Type)

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

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

fn open(     self ) -> (<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as Join>::Mask, <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as Join>::Value)

unsafe fn get(     v: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as Join>::Value,     i: u32 ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

impl<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 as Join>::Type, <B as Join>::Type, <C as Join>::Type)

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

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

fn open(self) -> (<(A, B, C) as Join>::Mask, <(A, B, C) as Join>::Value)

unsafe fn get(     v: &mut <(A, B, C) as Join>::Value,     i: u32 ) -> <(A, B, C) as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

impl Join for AtomicBitSet

type Type = u32

type Value = ()

type Mask = AtomicBitSet

fn open(self) -> (<AtomicBitSet as Join>::Mask, <AtomicBitSet as Join>::Value)

unsafe fn get(     &mut <AtomicBitSet as Join>::Value,     id: u32 ) -> <AtomicBitSet as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

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

type Type = u32

type Value = ()

type Mask = &'a BitSetNot<A>

fn open(     self ) -> (<&'a BitSetNot<A> as Join>::Mask, <&'a BitSetNot<A> as Join>::Value)

unsafe fn get(     &mut <&'a BitSetNot<A> as Join>::Value,     id: u32 ) -> <&'a BitSetNot<A> as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

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

type Type = (<A as Join>::Type, <B as Join>::Type)

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

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

fn open(self) -> (<(A, B) as Join>::Mask, <(A, B) as Join>::Value)

unsafe fn get(v: &mut <(A, B) as Join>::Value, i: u32) -> <(A, B) as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

impl<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 as Join>::Type, <B as Join>::Type, <C as Join>::Type, <D as Join>::Type)

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

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

fn open(self) -> (<(A, B, C, D) as Join>::Mask, <(A, B, C, D) as Join>::Value)

unsafe fn get(     v: &mut <(A, B, C, D) as Join>::Value,     i: u32 ) -> <(A, B, C, D) as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

impl<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 as Join>::Type, <B as Join>::Type, <C as Join>::Type, <D as Join>::Type, <E as Join>::Type, <F as Join>::Type, <G as Join>::Type, <H as Join>::Type, <I as Join>::Type, <J as Join>::Type, <K as Join>::Type, <L as Join>::Type)

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

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

fn open(     self ) -> (<(A, B, C, D, E, F, G, H, I, J, K, L) as Join>::Mask, <(A, B, C, D, E, F, G, H, I, J, K, L) as Join>::Value)

unsafe fn get(     v: &mut <(A, B, C, D, E, F, G, H, I, J, K, L) as Join>::Value,     i: u32 ) -> <(A, B, C, D, E, F, G, H, I, J, K, L) as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

impl<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 as Join>::Type, <B as Join>::Type, <C as Join>::Type, <D as Join>::Type, <E as Join>::Type, <F as Join>::Type, <G as Join>::Type, <H as Join>::Type)

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

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

fn open(     self ) -> (<(A, B, C, D, E, F, G, H) as Join>::Mask, <(A, B, C, D, E, F, G, H) as Join>::Value)

unsafe fn get(     v: &mut <(A, B, C, D, E, F, G, H) as Join>::Value,     i: u32 ) -> <(A, B, C, D, E, F, G, H) as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

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

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

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

fn open(     self ) -> (<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as Join>::Mask, <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as Join>::Value)

unsafe fn get(     v: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as Join>::Value,     i: u32 ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

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

type Type = u32

type Value = ()

type Mask = &'a BitSetOr<A, B>

fn open(     self ) -> (<&'a BitSetOr<A, B> as Join>::Mask, <&'a BitSetOr<A, B> as Join>::Value)

unsafe fn get(     &mut <&'a BitSetOr<A, B> as Join>::Value,     id: u32 ) -> <&'a BitSetOr<A, B> as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

impl<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 as Join>::Type, <B as Join>::Type, <C as Join>::Type, <D as Join>::Type, <E as Join>::Type, <F as Join>::Type, <G as Join>::Type, <H as Join>::Type, <I as Join>::Type, <J as Join>::Type)

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

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

fn open(     self ) -> (<(A, B, C, D, E, F, G, H, I, J) as Join>::Mask, <(A, B, C, D, E, F, G, H, I, J) as Join>::Value)

unsafe fn get(     v: &mut <(A, B, C, D, E, F, G, H, I, J) as Join>::Value,     i: u32 ) -> <(A, B, C, D, E, F, G, H, I, J) as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

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

type Type = u32

type Value = ()

type Mask = BitSetAnd<A, B>

fn open(     self ) -> (<BitSetAnd<A, B> as Join>::Mask, <BitSetAnd<A, B> as Join>::Value)

unsafe fn get(     &mut <BitSetAnd<A, B> as Join>::Value,     id: u32 ) -> <BitSetAnd<A, B> as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

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

type Type = u32

type Value = ()

type Mask = &'a BitSetAnd<A, B>

fn open(     self ) -> (<&'a BitSetAnd<A, B> as Join>::Mask, <&'a BitSetAnd<A, B> as Join>::Value)

unsafe fn get(     &mut <&'a BitSetAnd<A, B> as Join>::Value,     id: u32 ) -> <&'a BitSetAnd<A, B> as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

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

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

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

fn open(     self ) -> (<(A, B, C, D, E, F) as Join>::Mask, <(A, B, C, D, E, F) as Join>::Value)

unsafe fn get(     v: &mut <(A, B, C, D, E, F) as Join>::Value,     i: u32 ) -> <(A, B, C, D, E, F) as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

impl<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 as Join>::Type, <B as Join>::Type, <C as Join>::Type, <D as Join>::Type, <E as Join>::Type, <F as Join>::Type, <G as Join>::Type)

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

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

fn open(     self ) -> (<(A, B, C, D, E, F, G) as Join>::Mask, <(A, B, C, D, E, F, G) as Join>::Value)

unsafe fn get(     v: &mut <(A, B, C, D, E, F, G) as Join>::Value,     i: u32 ) -> <(A, B, C, D, E, F, G) as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

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

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

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

fn open(     self ) -> (<(A, B, C, D, E) as Join>::Mask, <(A, B, C, D, E) as Join>::Value)

unsafe fn get(     v: &mut <(A, B, C, D, E) as Join>::Value,     i: u32 ) -> <(A, B, C, D, E) as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

impl<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 as Join>::Type, <B as Join>::Type, <C as Join>::Type, <D as Join>::Type, <E as Join>::Type, <F as Join>::Type, <G as Join>::Type, <H as Join>::Type, <I as Join>::Type, <J as Join>::Type, <K as Join>::Type, <L as Join>::Type, <M as Join>::Type, <N as Join>::Type, <O as Join>::Type)

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

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

fn open(     self ) -> (<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as Join>::Mask, <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as Join>::Value)

unsafe fn get(     v: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as Join>::Value,     i: u32 ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

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

type Type = (<A as Join>::Type,)

type Value = (<A as Join>::Value,)

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

fn open(self) -> (<(A,) as Join>::Mask, <(A,) as Join>::Value)

unsafe fn get(v: &mut <(A,) as Join>::Value, i: u32) -> <(A,) as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

impl<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 as Join>::Type, <B as Join>::Type, <C as Join>::Type, <D as Join>::Type, <E as Join>::Type, <F as Join>::Type, <G as Join>::Type, <H as Join>::Type, <I as Join>::Type, <J as Join>::Type, <K as Join>::Type, <L as Join>::Type, <M as Join>::Type, <N as Join>::Type)

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

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

fn open(     self ) -> (<(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as Join>::Mask, <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as Join>::Value)

unsafe fn get(     v: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as Join>::Value,     i: u32 ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

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

type Type = u32

type Value = ()

type Mask = BitSetXor<A, B>

fn open(     self ) -> (<BitSetXor<A, B> as Join>::Mask, <BitSetXor<A, B> as Join>::Value)

unsafe fn get(     &mut <BitSetXor<A, B> as Join>::Value,     id: u32 ) -> <BitSetXor<A, B> as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

impl<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 as Join>::Type, <B as Join>::Type, <C as Join>::Type, <D as Join>::Type, <E as Join>::Type, <F as Join>::Type, <G as Join>::Type, <H as Join>::Type, <I as Join>::Type)

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

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

fn open(     self ) -> (<(A, B, C, D, E, F, G, H, I) as Join>::Mask, <(A, B, C, D, E, F, G, H, I) as Join>::Value)

unsafe fn get(     v: &mut <(A, B, C, D, E, F, G, H, I) as Join>::Value,     i: u32 ) -> <(A, B, C, D, E, F, G, H, I) as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

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

type Type = u32

type Value = ()

type Mask = BitSetNot<A>

fn open(self) -> (<BitSetNot<A> as Join>::Mask, <BitSetNot<A> as Join>::Value)

unsafe fn get(     &mut <BitSetNot<A> as Join>::Value,     id: u32 ) -> <BitSetNot<A> as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

impl<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 as Join>::Type, <B as Join>::Type, <C as Join>::Type, <D as Join>::Type, <E as Join>::Type, <F as Join>::Type, <G as Join>::Type, <H as Join>::Type, <I as Join>::Type, <J as Join>::Type, <K as Join>::Type, <L as Join>::Type, <M as Join>::Type)

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

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

fn open(     self ) -> (<(A, B, C, D, E, F, G, H, I, J, K, L, M) as Join>::Mask, <(A, B, C, D, E, F, G, H, I, J, K, L, M) as Join>::Value)

unsafe fn get(     v: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M) as Join>::Value,     i: u32 ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M) as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

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

type Type = u32

type Value = ()

type Mask = BitSetOr<A, B>

fn open(     self ) -> (<BitSetOr<A, B> as Join>::Mask, <BitSetOr<A, B> as Join>::Value)

unsafe fn get(     &mut <BitSetOr<A, B> as Join>::Value,     id: u32 ) -> <BitSetOr<A, B> as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

impl<'a> Join for &'a AtomicBitSet

type Type = u32

type Value = ()

type Mask = &'a AtomicBitSet

fn open(     self ) -> (<&'a AtomicBitSet as Join>::Mask, <&'a AtomicBitSet as Join>::Value)

unsafe fn get(     &mut <&'a AtomicBitSet as Join>::Value,     id: u32 ) -> <&'a AtomicBitSet as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

impl<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 as Join>::Type, <B as Join>::Type, <C as Join>::Type, <D as Join>::Type, <E as Join>::Type, <F as Join>::Type, <G as Join>::Type, <H as Join>::Type, <I as Join>::Type, <J as Join>::Type, <K as Join>::Type)

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

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

fn open(     self ) -> (<(A, B, C, D, E, F, G, H, I, J, K) as Join>::Mask, <(A, B, C, D, E, F, G, H, I, J, K) as Join>::Value)

unsafe fn get(     v: &mut <(A, B, C, D, E, F, G, H, I, J, K) as Join>::Value,     i: u32 ) -> <(A, B, C, D, E, F, G, H, I, J, K) as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

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

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

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

fn open(     self ) -> (<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as Join>::Mask, <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as Join>::Value)

unsafe fn get(     v: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as Join>::Value,     i: u32 ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as Join>::Type

Important traits for JoinIter<J>

impl<J> Iterator for JoinIter<J> where
    J: Join,  type Item = <J as Join>::Type;

fn join(self) -> JoinIter<Self>

Implementors

• impl<'rf, 'st, C, S, B, Restrict> Join for &'rf RestrictedStorage<'rf, 'st, C, S, B, Restrict> where     'st: 'rf,     B: Borrow<BitSet>,     C: Component,     S: Borrow<<C as Component>::Storage>,  type Type = PairedStorage<'rf, 'st, C, &'rf <C as Component>::Storage, &'rf BitSet, Restrict>; type Value = (&'rf <C as Component>::Storage, &'rf Fetch<'st, EntitiesRes>, &'rf BitSet); type Mask = &'rf BitSet;

• impl<'a> Join for AntiStorage<'a> type Type = (); type Value = (); type Mask = BitSetNot<&'a BitSet>;

• impl<'a, T> Join for &'a ChangeSet<T> type Type = &'a T; type Value = &'a DenseVecStorage<T>; type Mask = &'a BitSet;

• impl<'a> Join for &'a BitSet type Type = u32; type Value = (); type Mask = &'a BitSet;

• impl Join for BitSet type Type = u32; type Value = (); type Mask = BitSet;

• impl<'a, 'e, T, D> Join for &'a Storage<'e, T, D> where     D: Deref<Target = MaskedStorage<T>>,     T: Component,  type Type = &'a T; type Value = &'a <T as Component>::Storage; type Mask = &'a BitSet;

• impl<'a, 'e, T, D> Join for &'a mut Storage<'e, T, D> where     D: DerefMut<Target = MaskedStorage<T>>,     T: Component,  type Type = &'a mut T; type Value = &'a mut <T as Component>::Storage; type Mask = &'a BitSet;

• impl<'rf, 'st, C, S, B, Restrict> Join for &'rf mut RestrictedStorage<'rf, 'st, C, S, B, Restrict> where     'st: 'rf,     B: Borrow<BitSet>,     C: Component,     S: BorrowMut<<C as Component>::Storage>,  type Type = PairedStorage<'rf, 'st, C, &'rf mut <C as Component>::Storage, &'rf BitSet, Restrict>; type Value = (&'rf mut <C as Component>::Storage, &'rf Fetch<'st, EntitiesRes>, &'rf BitSet); type Mask = &'rf BitSet;

• impl<'a, T> Join for &'a mut ChangeSet<T> type Type = &'a mut T; type Value = &'a mut DenseVecStorage<T>; type Mask = &'a BitSet;

• impl<'a> Join for &'a EntitiesRes type Type = Entity; type Value = &'a EntitiesRes; type Mask = BitSetOr<&'a BitSet, &'a AtomicBitSet>;

• impl<T> Join for ChangeSet<T> type Type = T; type Value = DenseVecStorage<T>; type Mask = BitSet;