[−][src]Struct goggles::join::JoinTuple

pub struct JoinTuple<T>(_);

If the inner type is a tuple of types which implement Join, then this type will implement Join all of them.

Trait Implementations

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

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

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

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

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

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

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

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

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

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, ::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, ::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, ::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, ::Mask, <J as Join>::Mask, <K as Join>::Mask, <L as Join>::Mask) as BitAnd>::Value`

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

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, ::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, ::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, ::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, ::Mask, <J as Join>::Mask, <K as Join>::Mask, <L as Join>::Mask, <M as Join>::Mask) as BitAnd>::Value`

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

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, ::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, ::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, ::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, ::Mask, <J as Join>::Mask, <K as Join>::Mask, <L as Join>::Mask, <M as Join>::Mask, <N as Join>::Mask) as BitAnd>::Value`

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

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, ::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, ::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, ::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, ::Mask, <J as Join>::Mask, <K as Join>::Mask, <L as Join>::Mask, <M as Join>::Mask, <N as Join>::Mask, <O as Join>::Mask) as BitAnd>::Value`

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

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

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

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

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

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

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

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

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

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

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

`impl<A, B, C> Join for JoinTuple<(A, B, C)> where A: Join, B: Join, C: Join, (<A as Join>::Mask, ::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, ::Mask, <C as Join>::Mask) as BitAnd>::Value`

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

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

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

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

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

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

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

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

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

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

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

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

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

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

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

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

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

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

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

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

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

`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, ::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, ::Mask, <C as Join>::Mask, <D as Join>::Mask, <E as Join>::Mask, <F as Join>::Mask, <G as Join>::Mask, <H as Join>::Mask) as BitAnd>::Value`

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

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

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

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

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

Auto Trait Implementations

`impl<T> RefUnwindSafe for JoinTuple<T> where T: RefUnwindSafe,`

`impl<T> Send for JoinTuple<T> where T: Send,`

`impl<T> Sync for JoinTuple<T> where T: Sync,`

`impl<T> Unpin for JoinTuple<T> where T: Unpin,`

`impl<T> UnwindSafe for JoinTuple<T> where T: UnwindSafe,`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`pub fn type_id(&self) -> TypeId`[src]

`impl<T> Any for T where T: Any,` [src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`pub fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`pub fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> From<T> for T`[src]

`pub fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`pub fn into(self) -> U`[src]

`impl<J> IntoJoin for J where J: Join,` [src]

`type Item = <J as Join>::Item`

`type IntoJoin = J`

`pub fn into_join(Self) -> <J as IntoJoin>::IntoJoin`[src]

`impl<J> IntoJoinExt for J where J: IntoJoin,` [src]

`fn join(self) -> JoinIter<Self::IntoJoin>ⓘNotable traits for JoinIter<J> impl<J: Join> Iterator for JoinIter<J> type Item = J::Item; where Self: Sized, <Self::IntoJoin as Join>::Mask: BitSetConstrained,` [src]

`fn join_unconstrained(self) -> JoinIter<Self::IntoJoin>ⓘNotable traits for JoinIter<J> impl<J: Join> Iterator for JoinIter<J> type Item = J::Item; where Self: Sized,` [src]

`fn maybe(self) -> MaybeJoin<Self::IntoJoin> where Self: Sized,` [src]

`impl<J> ParJoinExt for J where J: IntoJoin,` [src]

`fn par_join(self) -> JoinParIter<Self::IntoJoin> where Self: Sized + Send + Sync, Self::Item: Send, <Self::IntoJoin as Join>::Mask: BitSetConstrained + Send + Sync,` [src]

`fn par_join_unconstrained(self) -> JoinParIter<Self::IntoJoin> where Self: Sized + Send + Sync, Self::Item: Send, <Self::IntoJoin as Join>::Mask: Send + Sync,` [src]

`impl<T> Pointable for T`

`pub const ALIGN: usize`

`type Init = T`

The type for initializers.

`pub unsafe fn init(init: <T as Pointable>::Init) -> usize`

`pub unsafe fn deref<'a>(ptr: usize) -> &'a T`

`pub unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T`

`pub unsafe fn drop(ptr: usize)`

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`pub fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`pub fn try_into(self) -> Result<U, >::Error>`[src]

[−][src]Struct goggles::join::JoinTuple

Trait Implementations

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

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

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

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

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

unsafe fn get(access: &Self::Access, index: Index) -> Self::Item[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

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

unsafe fn get(access: &Self::Access, index: Index) -> Self::Item[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

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

unsafe fn get(access: &Self::Access, index: Index) -> Self::Item[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

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

unsafe fn get(access: &Self::Access, index: Index) -> Self::Item[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

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

unsafe fn get(access: &Self::Access, index: Index) -> Self::Item[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)

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

unsafe fn get(access: &Self::Access, index: Index) -> Self::Item[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)

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

unsafe fn get(access: &Self::Access, index: Index) -> Self::Item[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)

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

unsafe fn get(access: &Self::Access, index: Index) -> Self::Item[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)

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

unsafe fn get(access: &Self::Access, index: Index) -> Self::Item[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)

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

unsafe fn get(access: &Self::Access, index: Index) -> Self::Item[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)

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

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

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

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

unsafe fn get(access: &Self::Access, index: Index) -> Self::Item[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)

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

unsafe fn get(access: &Self::Access, index: Index) -> Self::Item[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)

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

unsafe fn get(access: &Self::Access, index: Index) -> Self::Item[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)

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

unsafe fn get(access: &Self::Access, index: Index) -> Self::Item[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)

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

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

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

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

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

`fn open(self) -> (Self::Mask, Self::Access)`[src]

`unsafe fn get(access: &Self::Access, index: Index) -> Self::Item`[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`

`fn open(self) -> (Self::Mask, Self::Access)`[src]

`unsafe fn get(access: &Self::Access, index: Index) -> Self::Item`[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`

`fn open(self) -> (Self::Mask, Self::Access)`[src]

`unsafe fn get(access: &Self::Access, index: Index) -> Self::Item`[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`

`fn open(self) -> (Self::Mask, Self::Access)`[src]

`unsafe fn get(access: &Self::Access, index: Index) -> Self::Item`[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`

`fn open(self) -> (Self::Mask, Self::Access)`[src]

`unsafe fn get(access: &Self::Access, index: Index) -> Self::Item`[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)`

`fn open(self) -> (Self::Mask, Self::Access)`[src]

`unsafe fn get(access: &Self::Access, index: Index) -> Self::Item`[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)`

`fn open(self) -> (Self::Mask, Self::Access)`[src]

`unsafe fn get(access: &Self::Access, index: Index) -> Self::Item`[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)`

`fn open(self) -> (Self::Mask, Self::Access)`[src]

`unsafe fn get(access: &Self::Access, index: Index) -> Self::Item`[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)`

`fn open(self) -> (Self::Mask, Self::Access)`[src]

`unsafe fn get(access: &Self::Access, index: Index) -> Self::Item`[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)`

`fn open(self) -> (Self::Mask, Self::Access)`[src]

`unsafe fn get(access: &Self::Access, index: Index) -> Self::Item`[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)`

`fn open(self) -> (Self::Mask, Self::Access)`[src]

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

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

`fn open(self) -> (Self::Mask, Self::Access)`[src]

`unsafe fn get(access: &Self::Access, index: Index) -> Self::Item`[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)`

`fn open(self) -> (Self::Mask, Self::Access)`[src]

`unsafe fn get(access: &Self::Access, index: Index) -> Self::Item`[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)`

`fn open(self) -> (Self::Mask, Self::Access)`[src]

`unsafe fn get(access: &Self::Access, index: Index) -> Self::Item`[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)`

`fn open(self) -> (Self::Mask, Self::Access)`[src]

`unsafe fn get(access: &Self::Access, index: Index) -> Self::Item`[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)`

`fn open(self) -> (Self::Mask, Self::Access)`[src]

`unsafe fn get(access: &Self::Access, index: Index) -> Self::Item`[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)`