[−][src]Trait goggles::join::Join

pub trait Join {
    type Item;
    type Access;
    type Mask: BitSetLike;
    fn open(self) -> (Self::Mask, Self::Access);

    unsafe fn get(access: &Self::Access, index: Index) -> Self::Item;
}

Associated Types

type Item

type Access

type Mask: BitSetLike

Loading content...

Required methods

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

unsafe fn get(access: &Self::Access, index: Index) -> Self::Item

Get a value out of the access type returned from open.

MUST be called only with indexes which are present in the mask returned along with the access value from open.

You must only allow one Self::Item for a given index to be alive at any given time. It is allowed for a Join impl to have Item be a mutable reference that would alias if get were called multiple times on the same index.

A simpler, more restrictive version of this rule that all of the uses of Join impls currently follow is that Join::get may only be called once per index for a given Access object.

Loading content...

Implementations on Foreign Types

impl Join for BitSet[src]

type Item = Index

type Access = ()

type Mask = Self

impl<'a> Join for &'a BitSet[src]

type Item = Index

type Access = ()

type Mask = Self

impl Join for AtomicBitSet[src]

type Item = Index

type Access = ()

type Mask = Self

impl<'a> Join for &'a AtomicBitSet[src]

type Item = Index

type Access = ()

type Mask = Self

impl Join for BitSetAll[src]

type Item = Index

type Access = ()

type Mask = Self

impl<'a> Join for &'a BitSetAll[src]

type Item = Index

type Access = ()

type Mask = Self

impl<A> Join for BitSetNot<A> where
    A: BitSetLike, [src]

type Item = Index

type Access = ()

type Mask = Self

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

type Item = Index

type Access = ()

type Mask = Self

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

type Item = Index

type Access = ()

type Mask = Self

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

type Item = Index

type Access = ()

type Mask = Self

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

type Item = Index

type Access = ()

type Mask = Self

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

type Item = Index

type Access = ()

type Mask = Self

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

type Item = Index

type Access = ()

type Mask = Self

impl<'a> Join for &'a dyn BitSetLike[src]

type Item = Index

type Access = ()

type Mask = Self

Loading content...

Implementors

impl<'a> Join for &'a Allocator[src]

type Item = Entity

type Access = &'a Allocator

type Mask = LiveBitSet<'a>

impl<'a, S: RawStorage> Join for &'a MaskedStorage<S>[src]

type Item = &'a S::Item

type Access = &'a S

type Mask = &'a BitSet

impl<'a, S: RawStorage> Join for &'a mut MaskedStorage<S>[src]

type Item = &'a mut S::Item

type Access = &'a S

type Mask = &'a BitSet

impl<'a, S: RawStorage> Join for GuardedJoin<'a, S>[src]

type Item = ElementGuard<'a, S>

type Access = &'a S

type Mask = &'a BitSet

impl<'a, S: TrackedStorage> Join for ModifiedJoin<'a, S>[src]

type Item = Option<&'a S::Item>

type Access = (&'a BitSet, &'a S)

type Mask = &'a ModifiedBitSet

impl<'a, S: TrackedStorage> Join for ModifiedJoinMut<'a, S>[src]

type Item = Option<&'a mut S::Item>

type Access = (&'a BitSet, &'a S)

type Mask = &'a ModifiedBitSet

impl<A> Join for JoinTuple<(A,)> where
    A: Join,
    (<A as Join>::Mask,): BitAnd, [src]

type Item = (A::Item,)

type Access = (A::Access,)

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

impl<A, B> Join for JoinTuple<(A, B)> where
    A: Join,
    B: Join,
    (<A as Join>::Mask, <B as Join>::Mask): BitAnd, [src]

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

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

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

impl<A, B, C> Join for JoinTuple<(A, B, C)> where
    A: Join,
    B: Join,
    C: Join,
    (<A as Join>::Mask, <B as Join>::Mask, <C as Join>::Mask): BitAnd, [src]

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

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

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

impl<A, B, C, D> Join for JoinTuple<(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]

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

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

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

impl<A, B, C, D, E> Join for JoinTuple<(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]

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

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

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

impl<A, B, C, D, E, F> Join for JoinTuple<(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]

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

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

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

impl<A, B, C, D, E, F, G> Join for JoinTuple<(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]

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

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

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

impl<A, B, C, D, E, F, G, H> Join for JoinTuple<(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]

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

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

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

impl<A, B, C, D, E, F, G, H, I> Join for JoinTuple<(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]

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

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

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

impl<A, B, C, D, E, F, G, H, I, J> Join for JoinTuple<(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]

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

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

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

impl<A, B, C, D, E, F, G, H, I, J, K> Join for JoinTuple<(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]

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

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

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

impl<A, B, C, D, E, F, G, H, I, J, K, L> Join for JoinTuple<(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]

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

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

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M> Join for JoinTuple<(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]

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

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

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N> Join for JoinTuple<(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]

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

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

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Join for JoinTuple<(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]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> Join for JoinTuple<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)> 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,
    S: 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, <S as Join>::Mask): BitAnd, [src]

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

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

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, <S as Join>::Mask) as BitAnd>::Value

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Join for JoinTuple<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)> 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,
    S: Join,
    T: 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, <S as Join>::Mask, <T as Join>::Mask): BitAnd, [src]

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

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

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, <S as Join>::Mask, <T as Join>::Mask) as BitAnd>::Value

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> Join for JoinTuple<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)> 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,
    S: Join,
    T: Join,
    U: 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, <S as Join>::Mask, <T as Join>::Mask, <U as Join>::Mask): BitAnd, [src]

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

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

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, <S as Join>::Mask, <T as Join>::Mask, <U as Join>::Mask) as BitAnd>::Value

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> Join for JoinTuple<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)> 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,
    S: Join,
    T: Join,
    U: Join,
    V: 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, <S as Join>::Mask, <T as Join>::Mask, <U as Join>::Mask, <V as Join>::Mask): BitAnd, [src]

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

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

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, <S as Join>::Mask, <T as Join>::Mask, <U as Join>::Mask, <V as Join>::Mask) as BitAnd>::Value

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> Join for JoinTuple<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)> 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,
    S: Join,
    T: Join,
    U: Join,
    V: Join,
    W: 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, <S as Join>::Mask, <T as Join>::Mask, <U as Join>::Mask, <V as Join>::Mask, <W as Join>::Mask): BitAnd, [src]

type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item, J::Item, K::Item, L::Item, M::Item, N::Item, O::Item, P::Item, Q::Item, R::Item, S::Item, T::Item, U::Item, V::Item, W::Item)

type Access = (A::Access, B::Access, C::Access, D::Access, E::Access, F::Access, G::Access, H::Access, I::Access, J::Access, K::Access, L::Access, M::Access, N::Access, O::Access, P::Access, Q::Access, R::Access, S::Access, T::Access, U::Access, V::Access, W::Access)

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, <S as Join>::Mask, <T as Join>::Mask, <U as Join>::Mask, <V as Join>::Mask, <W as Join>::Mask) as BitAnd>::Value

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> Join for JoinTuple<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)> 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,
    S: Join,
    T: Join,
    U: Join,
    V: Join,
    W: Join,
    X: 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, <S as Join>::Mask, <T as Join>::Mask, <U as Join>::Mask, <V as Join>::Mask, <W as Join>::Mask, <X as Join>::Mask): BitAnd, [src]

type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item, J::Item, K::Item, L::Item, M::Item, N::Item, O::Item, P::Item, Q::Item, R::Item, S::Item, T::Item, U::Item, V::Item, W::Item, X::Item)

type Access = (A::Access, B::Access, C::Access, D::Access, E::Access, F::Access, G::Access, H::Access, I::Access, J::Access, K::Access, L::Access, M::Access, N::Access, O::Access, P::Access, Q::Access, R::Access, S::Access, T::Access, U::Access, V::Access, W::Access, X::Access)

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, <S as Join>::Mask, <T as Join>::Mask, <U as Join>::Mask, <V as Join>::Mask, <W as Join>::Mask, <X as Join>::Mask) as BitAnd>::Value

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y> Join for JoinTuple<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)> 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,
    S: Join,
    T: Join,
    U: Join,
    V: Join,
    W: Join,
    X: Join,
    Y: 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, <S as Join>::Mask, <T as Join>::Mask, <U as Join>::Mask, <V as Join>::Mask, <W as Join>::Mask, <X as Join>::Mask, <Y as Join>::Mask): BitAnd, [src]

type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item, J::Item, K::Item, L::Item, M::Item, N::Item, O::Item, P::Item, Q::Item, R::Item, S::Item, T::Item, U::Item, V::Item, W::Item, X::Item, Y::Item)

type Access = (A::Access, B::Access, C::Access, D::Access, E::Access, F::Access, G::Access, H::Access, I::Access, J::Access, K::Access, L::Access, M::Access, N::Access, O::Access, P::Access, Q::Access, R::Access, S::Access, T::Access, U::Access, V::Access, W::Access, X::Access, Y::Access)

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, <S as Join>::Mask, <T as Join>::Mask, <U as Join>::Mask, <V as Join>::Mask, <W as Join>::Mask, <X as Join>::Mask, <Y as Join>::Mask) as BitAnd>::Value

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> Join for JoinTuple<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)> 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,
    S: Join,
    T: Join,
    U: Join,
    V: Join,
    W: Join,
    X: Join,
    Y: Join,
    Z: 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, <S as Join>::Mask, <T as Join>::Mask, <U as Join>::Mask, <V as Join>::Mask, <W as Join>::Mask, <X as Join>::Mask, <Y as Join>::Mask, <Z as Join>::Mask): BitAnd, [src]

type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item, J::Item, K::Item, L::Item, M::Item, N::Item, O::Item, P::Item, Q::Item, R::Item, S::Item, T::Item, U::Item, V::Item, W::Item, X::Item, Y::Item, Z::Item)

type Access = (A::Access, B::Access, C::Access, D::Access, E::Access, F::Access, G::Access, H::Access, I::Access, J::Access, K::Access, L::Access, M::Access, N::Access, O::Access, P::Access, Q::Access, R::Access, S::Access, T::Access, U::Access, V::Access, W::Access, X::Access, Y::Access, Z::Access)

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, <S as Join>::Mask, <T as Join>::Mask, <U as Join>::Mask, <V as Join>::Mask, <W as Join>::Mask, <X as Join>::Mask, <Y as Join>::Mask, <Z as Join>::Mask) as BitAnd>::Value

impl<J: Join> Join for MaybeJoin<J>[src]

type Item = Option<J::Item>

type Access = (J::Mask, J::Access)

type Mask = BitSetAll

Loading content...