[−][src]Trait oxygengine_core::ecs::prelude::Join
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(); 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.
Safety
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.
Safety
- A call to
get
must be preceded by a check ifid
is part ofSelf::Mask
- The implementation of this method may use unsafe code, but has no invariants to meet
Provided methods
fn join(self) -> JoinIter<Self>ⓘ
Create a joined iterator over the contents.
fn maybe(self) -> MaybeJoin<Self>
Returns a Join
-able structure that yields all indices, returning
None
for all missing elements and Some(T)
for found elements.
WARNING: Do not have a join of only MaybeJoin
s. Otherwise the join
will iterate over every single index of the bitset. If you want a
join with all MaybeJoin
s, add an EntitiesRes
to the join as well
to bound the join to all entities that are alive.
struct ExampleSystem; impl<'a> System<'a> for ExampleSystem { type SystemData = ( WriteStorage<'a, Pos>, ReadStorage<'a, Vel>, ); fn run(&mut self, (mut positions, velocities): Self::SystemData) { for (mut position, maybe_velocity) in (&mut positions, velocities.maybe()).join() { if let Some(velocity) = maybe_velocity { position.x += velocity.x; position.y += velocity.y; } } } } fn main() { let mut world = World::new(); let mut dispatcher = DispatcherBuilder::new() .with(ExampleSystem, "example_system", &[]) .build(); dispatcher.setup(&mut world); let e1 = world.create_entity() .with(Pos { x: 0, y: 0 }) .with(Vel { x: 5, y: 2 }) .build(); let e2 = world.create_entity() .with(Pos { x: 0, y: 0 }) .build(); dispatcher.dispatch(&mut world); let positions = world.read_storage::<Pos>(); assert_eq!(positions.get(e1), Some(&Pos { x: 5, y: 2 })); assert_eq!(positions.get(e2), Some(&Pos { x: 0, y: 0 })); }
fn is_unconstrained() -> bool
If this Join
typically returns all indices in the mask, then iterating
over only it or combined with other joins that are also dangerous
will cause the JoinIter
/ParJoin
to go through all indices which
is usually not what is wanted and will kill performance.
Implementations on Foreign Types
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,
[src]
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)
[src]
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
[src]
v: &mut <(A, B, C, D, E) as Join>::Value,
i: u32
) -> <(A, B, C, D, E) as Join>::Type
fn is_unconstrained() -> bool
[src]
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,
[src]
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)
[src]
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
[src]
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
fn is_unconstrained() -> bool
[src]
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,
[src]
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)
[src]
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
[src]
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
fn is_unconstrained() -> bool
[src]
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,
[src]
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)
[src]
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
[src]
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
fn is_unconstrained() -> bool
[src]
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,
[src]
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)
[src]
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
[src]
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
fn is_unconstrained() -> bool
[src]
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,
[src]
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)
[src]
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
[src]
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
fn is_unconstrained() -> bool
[src]
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,
[src]
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)
[src]
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
[src]
v: &mut <(A, B, C, D) as Join>::Value,
i: u32
) -> <(A, B, C, D) as Join>::Type
fn is_unconstrained() -> bool
[src]
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,
[src]
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)
[src]
unsafe fn get(
v: &mut <(A, B, C) as Join>::Value,
i: u32
) -> <(A, B, C) as Join>::Type
[src]
v: &mut <(A, B, C) as Join>::Value,
i: u32
) -> <(A, B, C) as Join>::Type
fn is_unconstrained() -> bool
[src]
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,
[src]
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)
[src]
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
[src]
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
fn is_unconstrained() -> bool
[src]
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,
[src]
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)
[src]
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
[src]
v: &mut <(A, B, C, D, E, F, G) as Join>::Value,
i: u32
) -> <(A, B, C, D, E, F, G) as Join>::Type
fn is_unconstrained() -> bool
[src]
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,
[src]
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)
[src]
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
[src]
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
fn is_unconstrained() -> bool
[src]
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,
[src]
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)
[src]
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
[src]
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
fn is_unconstrained() -> bool
[src]
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,
[src]
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)
[src]
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
[src]
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
fn is_unconstrained() -> bool
[src]
impl<A, B> Join for (A, B) where
A: Join,
B: Join,
(<A as Join>::Mask, <B as Join>::Mask): BitAnd,
[src]
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)
[src]
unsafe fn get(v: &mut <(A, B) as Join>::Value, i: u32) -> <(A, B) as Join>::Type
[src]
fn is_unconstrained() -> bool
[src]
impl<A> Join for (A,) where
A: Join,
(<A as Join>::Mask,): BitAnd,
[src]
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)
[src]
unsafe fn get(v: &mut <(A,) as Join>::Value, i: u32) -> <(A,) as Join>::Type
[src]
fn is_unconstrained() -> bool
[src]
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,
[src]
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)
[src]
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
[src]
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
fn is_unconstrained() -> bool
[src]
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,
[src]
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)
[src]
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
[src]
v: &mut <(A, B, C, D, E, F) as Join>::Value,
i: u32
) -> <(A, B, C, D, E, F) as Join>::Type
fn is_unconstrained() -> bool
[src]
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,
[src]
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)
[src]
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
[src]
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
fn is_unconstrained() -> bool
[src]
Implementors
impl Join for AtomicBitSet
[src]
type Type = u32
type Value = ()
type Mask = AtomicBitSet
unsafe fn open(
self
) -> (<AtomicBitSet as Join>::Mask, <AtomicBitSet as Join>::Value)
[src]
self
) -> (<AtomicBitSet as Join>::Mask, <AtomicBitSet as Join>::Value)
unsafe fn get(
&mut <AtomicBitSet as Join>::Value,
id: u32
) -> <AtomicBitSet as Join>::Type
[src]
&mut <AtomicBitSet as Join>::Value,
id: u32
) -> <AtomicBitSet as Join>::Type
impl Join for BitSet
[src]
type Type = u32
type Value = ()
type Mask = BitSet
unsafe fn open(self) -> (<BitSet as Join>::Mask, <BitSet as Join>::Value)
[src]
unsafe fn get(&mut <BitSet as Join>::Value, id: u32) -> <BitSet as Join>::Type
[src]
impl<'a> Join for &'a (dyn BitSetLike + 'a)
[src]
type Type = u32
type Value = ()
type Mask = &'a (dyn BitSetLike + 'a)
unsafe fn open(
self
) -> (<&'a (dyn BitSetLike + 'a) as Join>::Mask, <&'a (dyn BitSetLike + 'a) as Join>::Value)
[src]
self
) -> (<&'a (dyn BitSetLike + 'a) as Join>::Mask, <&'a (dyn BitSetLike + 'a) as Join>::Value)
unsafe fn get(
&mut <&'a (dyn BitSetLike + 'a) as Join>::Value,
id: u32
) -> <&'a (dyn BitSetLike + 'a) as Join>::Type
[src]
&mut <&'a (dyn BitSetLike + 'a) as Join>::Value,
id: u32
) -> <&'a (dyn BitSetLike + 'a) as Join>::Type
impl<'a> Join for &'a AtomicBitSet
[src]
type Type = u32
type Value = ()
type Mask = &'a AtomicBitSet
unsafe fn open(
self
) -> (<&'a AtomicBitSet as Join>::Mask, <&'a AtomicBitSet as Join>::Value)
[src]
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
[src]
&mut <&'a AtomicBitSet as Join>::Value,
id: u32
) -> <&'a AtomicBitSet as Join>::Type
impl<'a> Join for &'a BitSet
[src]
type Type = u32
type Value = ()
type Mask = &'a BitSet
unsafe fn open(
self
) -> (<&'a BitSet as Join>::Mask, <&'a BitSet as Join>::Value)
[src]
self
) -> (<&'a BitSet as Join>::Mask, <&'a BitSet as Join>::Value)
unsafe fn get(
&mut <&'a BitSet as Join>::Value,
id: u32
) -> <&'a BitSet as Join>::Type
[src]
&mut <&'a BitSet as Join>::Value,
id: u32
) -> <&'a BitSet as Join>::Type
impl<'a> Join for &'a EntitiesRes
[src]
type Mask = BitSetOr<&'a BitSet, &'a AtomicBitSet>
type Type = Entity
type Value = &'a EntitiesRes
unsafe fn open(self) -> (<&'a EntitiesRes as Join>::Mask, &'a EntitiesRes)
[src]
unsafe fn get(v: &mut &'a EntitiesRes, idx: u32) -> Entity
[src]
impl<'a> Join for AntiStorage<'a>
[src]
type Mask = BitSetNot<&'a BitSet>
type Type = ()
type Value = ()
unsafe fn open(self) -> (<AntiStorage<'a> as Join>::Mask, ())
[src]
unsafe fn get(&mut (), u32)
[src]
impl<'a, 'b, T> Join for &'a Fetch<'b, T> where
T: Resource,
&'a T: Join,
[src]
T: Resource,
&'a T: Join,
type Type = <&'a T as Join>::Type
type Value = <&'a T as Join>::Value
type Mask = <&'a T as Join>::Mask
unsafe fn open(
self
) -> (<&'a Fetch<'b, T> as Join>::Mask, <&'a Fetch<'b, T> as Join>::Value)
[src]
self
) -> (<&'a Fetch<'b, T> as Join>::Mask, <&'a Fetch<'b, T> as Join>::Value)
unsafe fn get(
v: &mut <&'a Fetch<'b, T> as Join>::Value,
i: u32
) -> <&'a Fetch<'b, T> as Join>::Type
[src]
v: &mut <&'a Fetch<'b, T> as Join>::Value,
i: u32
) -> <&'a Fetch<'b, T> as Join>::Type
fn is_unconstrained() -> bool
[src]
impl<'a, 'b, T> Join for &'a Read<'b, T, DefaultProvider> where
T: Resource,
&'a T: Join,
[src]
T: Resource,
&'a T: Join,
type Type = <&'a T as Join>::Type
type Value = <&'a T as Join>::Value
type Mask = <&'a T as Join>::Mask
unsafe fn open(
self
) -> (<&'a Read<'b, T, DefaultProvider> as Join>::Mask, <&'a Read<'b, T, DefaultProvider> as Join>::Value)
[src]
self
) -> (<&'a Read<'b, T, DefaultProvider> as Join>::Mask, <&'a Read<'b, T, DefaultProvider> as Join>::Value)
unsafe fn get(
v: &mut <&'a Read<'b, T, DefaultProvider> as Join>::Value,
i: u32
) -> <&'a Read<'b, T, DefaultProvider> as Join>::Type
[src]
v: &mut <&'a Read<'b, T, DefaultProvider> as Join>::Value,
i: u32
) -> <&'a Read<'b, T, DefaultProvider> as Join>::Type
fn is_unconstrained() -> bool
[src]
impl<'a, 'b, T> Join for &'a Read<'b, T, PanicHandler> where
T: Resource,
&'a T: Join,
[src]
T: Resource,
&'a T: Join,
type Type = <&'a T as Join>::Type
type Value = <&'a T as Join>::Value
type Mask = <&'a T as Join>::Mask
unsafe fn open(
self
) -> (<&'a Read<'b, T, PanicHandler> as Join>::Mask, <&'a Read<'b, T, PanicHandler> as Join>::Value)
[src]
self
) -> (<&'a Read<'b, T, PanicHandler> as Join>::Mask, <&'a Read<'b, T, PanicHandler> as Join>::Value)
unsafe fn get(
v: &mut <&'a Read<'b, T, PanicHandler> as Join>::Value,
i: u32
) -> <&'a Read<'b, T, PanicHandler> as Join>::Type
[src]
v: &mut <&'a Read<'b, T, PanicHandler> as Join>::Value,
i: u32
) -> <&'a Read<'b, T, PanicHandler> as Join>::Type
fn is_unconstrained() -> bool
[src]
impl<'a, 'b, T> Join for &'a mut FetchMut<'b, T> where
T: Resource,
&'a mut T: Join,
[src]
T: Resource,
&'a mut T: Join,
type Type = <&'a mut T as Join>::Type
type Value = <&'a mut T as Join>::Value
type Mask = <&'a mut T as Join>::Mask
unsafe fn open(
self
) -> (<&'a mut FetchMut<'b, T> as Join>::Mask, <&'a mut FetchMut<'b, T> as Join>::Value)
[src]
self
) -> (<&'a mut FetchMut<'b, T> as Join>::Mask, <&'a mut FetchMut<'b, T> as Join>::Value)
unsafe fn get(
v: &mut <&'a mut FetchMut<'b, T> as Join>::Value,
i: u32
) -> <&'a mut FetchMut<'b, T> as Join>::Type
[src]
v: &mut <&'a mut FetchMut<'b, T> as Join>::Value,
i: u32
) -> <&'a mut FetchMut<'b, T> as Join>::Type
fn is_unconstrained() -> bool
[src]
impl<'a, 'b, T> Join for &'a mut Write<'b, T, DefaultProvider> where
T: Resource,
&'a mut T: Join,
[src]
T: Resource,
&'a mut T: Join,
type Type = <&'a mut T as Join>::Type
type Value = <&'a mut T as Join>::Value
type Mask = <&'a mut T as Join>::Mask
unsafe fn open(
self
) -> (<&'a mut Write<'b, T, DefaultProvider> as Join>::Mask, <&'a mut Write<'b, T, DefaultProvider> as Join>::Value)
[src]
self
) -> (<&'a mut Write<'b, T, DefaultProvider> as Join>::Mask, <&'a mut Write<'b, T, DefaultProvider> as Join>::Value)
unsafe fn get(
v: &mut <&'a mut Write<'b, T, DefaultProvider> as Join>::Value,
i: u32
) -> <&'a mut Write<'b, T, DefaultProvider> as Join>::Type
[src]
v: &mut <&'a mut Write<'b, T, DefaultProvider> as Join>::Value,
i: u32
) -> <&'a mut Write<'b, T, DefaultProvider> as Join>::Type
fn is_unconstrained() -> bool
[src]
impl<'a, 'b, T> Join for &'a mut Write<'b, T, PanicHandler> where
T: Resource,
&'a mut T: Join,
[src]
T: Resource,
&'a mut T: Join,
type Type = <&'a mut T as Join>::Type
type Value = <&'a mut T as Join>::Value
type Mask = <&'a mut T as Join>::Mask
unsafe fn open(
self
) -> (<&'a mut Write<'b, T, PanicHandler> as Join>::Mask, <&'a mut Write<'b, T, PanicHandler> as Join>::Value)
[src]
self
) -> (<&'a mut Write<'b, T, PanicHandler> as Join>::Mask, <&'a mut Write<'b, T, PanicHandler> as Join>::Value)
unsafe fn get(
v: &mut <&'a mut Write<'b, T, PanicHandler> as Join>::Value,
i: u32
) -> <&'a mut Write<'b, T, PanicHandler> as Join>::Type
[src]
v: &mut <&'a mut Write<'b, T, PanicHandler> as Join>::Value,
i: u32
) -> <&'a mut Write<'b, T, PanicHandler> as Join>::Type
fn is_unconstrained() -> bool
[src]
impl<'a, 'b, T, D> Join for Entries<'a, 'b, T, D> where
'b: 'a,
D: 'a + Deref<Target = MaskedStorage<T>>,
T: 'a + Component,
[src]
'b: 'a,
D: 'a + Deref<Target = MaskedStorage<T>>,
T: 'a + Component,
type Mask = BitSetAll
type Type = StorageEntry<'a, 'b, T, D>
type Value = &'a mut Storage<'b, T, D>
unsafe fn open(
self
) -> (<Entries<'a, 'b, T, D> as Join>::Mask, <Entries<'a, 'b, T, D> as Join>::Value)
[src]
self
) -> (<Entries<'a, 'b, T, D> as Join>::Mask, <Entries<'a, 'b, T, D> as Join>::Value)
unsafe fn get(
value: &mut <Entries<'a, 'b, T, D> as Join>::Value,
id: u32
) -> <Entries<'a, 'b, T, D> as Join>::Type
[src]
value: &mut <Entries<'a, 'b, T, D> as Join>::Value,
id: u32
) -> <Entries<'a, 'b, T, D> as Join>::Type
fn is_unconstrained() -> bool
[src]
impl<'a, 'e, T, D> Join for &'a Storage<'e, T, D> where
D: Deref<Target = MaskedStorage<T>>,
T: Component,
[src]
D: Deref<Target = MaskedStorage<T>>,
T: Component,
type Mask = &'a BitSet
type Type = &'a T
type Value = &'a <T as Component>::Storage
unsafe fn open(
self
) -> (<&'a Storage<'e, T, D> as Join>::Mask, <&'a Storage<'e, T, D> as Join>::Value)
[src]
self
) -> (<&'a Storage<'e, T, D> as Join>::Mask, <&'a Storage<'e, T, D> as Join>::Value)
unsafe fn get(v: &mut <&'a Storage<'e, T, D> as Join>::Value, i: u32) -> &'a T
[src]
impl<'a, 'e, T, D> Join for &'a mut Storage<'e, T, D> where
D: DerefMut<Target = MaskedStorage<T>>,
T: Component,
[src]
D: DerefMut<Target = MaskedStorage<T>>,
T: Component,
type Mask = &'a BitSet
type Type = &'a mut T
type Value = &'a mut <T as Component>::Storage
unsafe fn open(
self
) -> (<&'a mut Storage<'e, T, D> as Join>::Mask, <&'a mut Storage<'e, T, D> as Join>::Value)
[src]
self
) -> (<&'a mut Storage<'e, T, D> as Join>::Mask, <&'a mut Storage<'e, T, D> as Join>::Value)
unsafe fn get(
v: &mut <&'a mut Storage<'e, T, D> as Join>::Value,
i: u32
) -> &'a mut T
[src]
v: &mut <&'a mut Storage<'e, T, D> as Join>::Value,
i: u32
) -> &'a mut T
impl<'a, A> Join for &'a BitSetNot<A> where
A: BitSetLike,
[src]
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)
[src]
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
[src]
&mut <&'a BitSetNot<A> as Join>::Value,
id: u32
) -> <&'a BitSetNot<A> as Join>::Type
impl<'a, A, B> Join for &'a BitSetAnd<A, B> where
A: BitSetLike,
B: BitSetLike,
[src]
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)
[src]
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
[src]
&mut <&'a BitSetAnd<A, B> as Join>::Value,
id: u32
) -> <&'a BitSetAnd<A, B> as Join>::Type
impl<'a, A, B> Join for &'a BitSetOr<A, B> where
A: BitSetLike,
B: BitSetLike,
[src]
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)
[src]
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
[src]
&mut <&'a BitSetOr<A, B> as Join>::Value,
id: u32
) -> <&'a BitSetOr<A, B> as Join>::Type
impl<'a, T> Join for &'a ChangeSet<T>
[src]
type Mask = &'a BitSet
type Type = &'a T
type Value = &'a DenseVecStorage<T>
unsafe fn open(
self
) -> (<&'a ChangeSet<T> as Join>::Mask, <&'a ChangeSet<T> as Join>::Value)
[src]
self
) -> (<&'a ChangeSet<T> as Join>::Mask, <&'a ChangeSet<T> as Join>::Value)
unsafe fn get(
value: &mut <&'a ChangeSet<T> as Join>::Value,
id: u32
) -> <&'a ChangeSet<T> as Join>::Type
[src]
value: &mut <&'a ChangeSet<T> as Join>::Value,
id: u32
) -> <&'a ChangeSet<T> as Join>::Type
impl<'a, T> Join for &'a mut ChangeSet<T>
[src]
type Mask = &'a BitSet
type Type = &'a mut T
type Value = &'a mut DenseVecStorage<T>
unsafe fn open(
self
) -> (<&'a mut ChangeSet<T> as Join>::Mask, <&'a mut ChangeSet<T> as Join>::Value)
[src]
self
) -> (<&'a mut ChangeSet<T> as Join>::Mask, <&'a mut ChangeSet<T> as Join>::Value)
unsafe fn get(
v: &mut <&'a mut ChangeSet<T> as Join>::Value,
id: u32
) -> <&'a mut ChangeSet<T> as Join>::Type
[src]
v: &mut <&'a mut ChangeSet<T> as Join>::Value,
id: u32
) -> <&'a mut ChangeSet<T> as Join>::Type
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>,
[src]
'st: 'rf,
B: Borrow<BitSet>,
C: Component,
S: Borrow<<C as Component>::Storage>,
type Mask = &'rf BitSet
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)
unsafe fn open(
self
) -> (<&'rf RestrictedStorage<'rf, 'st, C, S, B, Restrict> as Join>::Mask, <&'rf RestrictedStorage<'rf, 'st, C, S, B, Restrict> as Join>::Value)
[src]
self
) -> (<&'rf RestrictedStorage<'rf, 'st, C, S, B, Restrict> as Join>::Mask, <&'rf RestrictedStorage<'rf, 'st, C, S, B, Restrict> as Join>::Value)
unsafe fn get(
value: &mut <&'rf RestrictedStorage<'rf, 'st, C, S, B, Restrict> as Join>::Value,
id: u32
) -> <&'rf RestrictedStorage<'rf, 'st, C, S, B, Restrict> as Join>::Type
[src]
value: &mut <&'rf RestrictedStorage<'rf, 'st, C, S, B, Restrict> as Join>::Value,
id: u32
) -> <&'rf RestrictedStorage<'rf, 'st, C, S, B, Restrict> as Join>::Type
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>,
[src]
'st: 'rf,
B: Borrow<BitSet>,
C: Component,
S: BorrowMut<<C as Component>::Storage>,
type Mask = &'rf BitSet
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)
unsafe fn open(
self
) -> (<&'rf mut RestrictedStorage<'rf, 'st, C, S, B, Restrict> as Join>::Mask, <&'rf mut RestrictedStorage<'rf, 'st, C, S, B, Restrict> as Join>::Value)
[src]
self
) -> (<&'rf mut RestrictedStorage<'rf, 'st, C, S, B, Restrict> as Join>::Mask, <&'rf mut RestrictedStorage<'rf, 'st, C, S, B, Restrict> as Join>::Value)
unsafe fn get(
value: &mut <&'rf mut RestrictedStorage<'rf, 'st, C, S, B, Restrict> as Join>::Value,
id: u32
) -> <&'rf mut RestrictedStorage<'rf, 'st, C, S, B, Restrict> as Join>::Type
[src]
value: &mut <&'rf mut RestrictedStorage<'rf, 'st, C, S, B, Restrict> as Join>::Value,
id: u32
) -> <&'rf mut RestrictedStorage<'rf, 'st, C, S, B, Restrict> as Join>::Type
impl<A> Join for BitSetNot<A> where
A: BitSetLike,
[src]
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)
[src]
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
[src]
&mut <BitSetNot<A> as Join>::Value,
id: u32
) -> <BitSetNot<A> as Join>::Type
impl<A, B> Join for BitSetAnd<A, B> where
A: BitSetLike,
B: BitSetLike,
[src]
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)
[src]
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
[src]
&mut <BitSetAnd<A, B> as Join>::Value,
id: u32
) -> <BitSetAnd<A, B> as Join>::Type
impl<A, B> Join for BitSetOr<A, B> where
A: BitSetLike,
B: BitSetLike,
[src]
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)
[src]
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
[src]
&mut <BitSetOr<A, B> as Join>::Value,
id: u32
) -> <BitSetOr<A, B> as Join>::Type
impl<A, B> Join for BitSetXor<A, B> where
A: BitSetLike,
B: BitSetLike,
[src]
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)
[src]
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
[src]
&mut <BitSetXor<A, B> as Join>::Value,
id: u32
) -> <BitSetXor<A, B> as Join>::Type
impl<T> Join for MaybeJoin<T> where
T: Join,
[src]
T: Join,
type Mask = BitSetAll
type Type = Option<<T as Join>::Type>
type Value = (<T as Join>::Mask, <T as Join>::Value)
unsafe fn open(
self
) -> (<MaybeJoin<T> as Join>::Mask, <MaybeJoin<T> as Join>::Value)
[src]
self
) -> (<MaybeJoin<T> as Join>::Mask, <MaybeJoin<T> as Join>::Value)
unsafe fn get(
&mut <MaybeJoin<T> as Join>::Value,
id: u32
) -> <MaybeJoin<T> as Join>::Type
[src]
&mut <MaybeJoin<T> as Join>::Value,
id: u32
) -> <MaybeJoin<T> as Join>::Type
fn is_unconstrained() -> bool
[src]
impl<T> Join for ChangeSet<T>
[src]
A Join
implementation for ChangeSet
that simply removes all the entries
on a call to get
.