Trait PieceSeq 

pub trait PieceSeq: 'static {
    // Required method
    fn build_each(self, cx: &mut BuildCx);
}

Children of a container: a tuple of pieces (the floem ViewTuple pattern — implemented ONLY for tuples, (), and PieceVec, never via a blanket, to stay coherent).

Required Methods

fn build_each(self, cx: &mut BuildCx)

Implementations on Foreign Types

impl PieceSeq for ()

fn build_each(self, _cx: &mut BuildCx)

impl<A> PieceSeq for (A,)

where A: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B> PieceSeq for (A, B)

where A: Piece, B: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C> PieceSeq for (A, B, C)

where A: Piece, B: Piece, C: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C, D> PieceSeq for (A, B, C, D)

where A: Piece, B: Piece, C: Piece, D: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C, D, E> PieceSeq for (A, B, C, D, E)

where A: Piece, B: Piece, C: Piece, D: Piece, E: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C, D, E, F> PieceSeq for (A, B, C, D, E, F)

where A: Piece, B: Piece, C: Piece, D: Piece, E: Piece, F: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C, D, E, F, G> PieceSeq for (A, B, C, D, E, F, G)

where A: Piece, B: Piece, C: Piece, D: Piece, E: Piece, F: Piece, G: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C, D, E, F, G, H> PieceSeq for (A, B, C, D, E, F, G, H)

where A: Piece, B: Piece, C: Piece, D: Piece, E: Piece, F: Piece, G: Piece, H: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C, D, E, F, G, H, I> PieceSeq for (A, B, C, D, E, F, G, H, I)

where A: Piece, B: Piece, C: Piece, D: Piece, E: Piece, F: Piece, G: Piece, H: Piece, I: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C, D, E, F, G, H, I, J> PieceSeq for (A, B, C, D, E, F, G, H, I, J)

where A: Piece, B: Piece, C: Piece, D: Piece, E: Piece, F: Piece, G: Piece, H: Piece, I: Piece, J: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C, D, E, F, G, H, I, J, K> PieceSeq for (A, B, C, D, E, F, G, H, I, J, K)

where A: Piece, B: Piece, C: Piece, D: Piece, E: Piece, F: Piece, G: Piece, H: Piece, I: Piece, J: Piece, K: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C, D, E, F, G, H, I, J, K, L> PieceSeq for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: Piece, B: Piece, C: Piece, D: Piece, E: Piece, F: Piece, G: Piece, H: Piece, I: Piece, J: Piece, K: Piece, L: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M> PieceSeq for (A, B, C, D, E, F, G, H, I, J, K, L, M)

where A: Piece, B: Piece, C: Piece, D: Piece, E: Piece, F: Piece, G: Piece, H: Piece, I: Piece, J: Piece, K: Piece, L: Piece, M: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N> PieceSeq for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

where A: Piece, B: Piece, C: Piece, D: Piece, E: Piece, F: Piece, G: Piece, H: Piece, I: Piece, J: Piece, K: Piece, L: Piece, M: Piece, N: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> PieceSeq for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

where A: Piece, B: Piece, C: Piece, D: Piece, E: Piece, F: Piece, G: Piece, H: Piece, I: Piece, J: Piece, K: Piece, L: Piece, M: Piece, N: Piece, O: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Q> PieceSeq for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Q)

where A: Piece, B: Piece, C: Piece, D: Piece, E: Piece, F: Piece, G: Piece, H: Piece, I: Piece, J: Piece, K: Piece, L: Piece, M: Piece, N: Piece, O: Piece, Q: Piece,

fn build_each(self, cx: &mut BuildCx)

Implementors

impl PieceSeq for PieceVec