Trait amethyst::ecs::join::Join

pub trait Join {
    type Type;
    type Value;
    type Mask: BitSetLike;
    unsafe 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

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

Open this join by returning the mask and the storages.

This is unsafe because implementations of this trait can permit the Value to be mutated independently of the Mask. If the Mask does not correctly report the status of the Value then illegal memory access can occur.

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

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

unsafe 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 BitSetOr<A, B> where     A: BitSetLike,     B: BitSetLike,

type Type = u32

type Value = ()

type Mask = BitSetOr<A, B>

unsafe 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, A> Join for &'a BitSetNot<A> where     A: BitSetLike,

type Type = u32

type Value = ()

type Mask = &'a BitSetNot<A>

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

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

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

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

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

unsafe 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, B> Join for BitSetXor<A, B> where     A: BitSetLike,     B: BitSetLike,

type Type = u32

type Value = ()

type Mask = BitSetXor<A, B>

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

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

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

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

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

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

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

unsafe 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<A, B> Join for BitSetAnd<A, B> where     A: BitSetLike,     B: BitSetLike,

type Type = u32

type Value = ()

type Mask = BitSetAnd<A, B>

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

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

unsafe 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 BitSetNot<A> where     A: BitSetLike,

type Type = u32

type Value = ()

type Mask = BitSetNot<A>

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

unsafe 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> Join for &'a AtomicBitSet

type Type = u32

type Value = ()

type Mask = &'a AtomicBitSet

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

unsafe 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, A, B> Join for &'a BitSetAnd<A, B> where     A: BitSetLike,     B: BitSetLike,

type Type = u32

type Value = ()

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

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

unsafe 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 Join for AtomicBitSet

type Type = u32

type Value = ()

type Mask = AtomicBitSet

unsafe 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, B> Join for &'a BitSetOr<A, B> where     A: BitSetLike,     B: BitSetLike,

type Type = u32

type Value = ()

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

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

Implementors

• 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, '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<'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 Join for BitSet type Type = u32; type Value = (); type Mask = 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, T> Join for &'a ChangeSet<T> type Type = &'a T; type Value = &'a DenseVecStorage<T>; type Mask = &'a BitSet;

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

• impl<'a> Join for &'a BitSet type Type = u32; type Value = (); 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<'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<T> Join for ChangeSet<T> type Type = T; type Value = DenseVecStorage<T>; type Mask = BitSet;