Trait acute_ecs::world::ComponentLayout

pub trait ComponentLayout {
    type Filter: for<'a> Filter<ArchetypeFilterData<'a>>;
    fn get_filter(&mut self) -> &mut Self::Filter;
    fn tailor_archetype(&self, archetype: &mut ArchetypeDescription);
}

Describes the types of a set of components attached to an entity.

Associated Types

type Filter: for<'a> Filter<ArchetypeFilterData<'a>>

A filter type which filters archetypes to an exact match with this layout.

Loading content...

Required methods

fn get_filter(&mut self) -> &mut Self::Filter

Gets the archetype filter for this layout.

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

Modifies an archetype description to include the components described by this layout.

Loading content...

Implementors

impl<I, C> ComponentLayout for PreallocComponentSource<I, C> where
    C: ComponentSource,
    I: Iterator<Item = Entity> + FusedIterator, 

type Filter = <C as ComponentLayout>::Filter

fn get_filter(
    &mut self
) -> &mut <PreallocComponentSource<I, C> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU> ComponentLayout for ComponentTupleSet<(), UWU> where
    UWU: ExactSizeIterator<Item = ()> + Iterator, 

type Filter = ComponentTupleFilter<()>

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, A> ComponentLayout for ComponentTupleSet<(A,), UWU> where
    A: Component,
    UWU: ExactSizeIterator<Item = (A,)> + Iterator, 

type Filter = ComponentTupleFilter<(A,)>

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(A,), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, A, B> ComponentLayout for ComponentTupleSet<(A, B), UWU> where
    A: Component,
    B: Component,
    UWU: ExactSizeIterator<Item = (A, B)> + Iterator, 

type Filter = ComponentTupleFilter<(A, B)>

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(A, B), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, A, B, C> ComponentLayout for ComponentTupleSet<(A, B, C), UWU> where
    A: Component,
    B: Component,
    C: Component,
    UWU: ExactSizeIterator<Item = (A, B, C)> + Iterator, 

type Filter = ComponentTupleFilter<(A, B, C)>

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(A, B, C), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, A, B, C, D> ComponentLayout for ComponentTupleSet<(A, B, C, D), UWU> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    UWU: ExactSizeIterator<Item = (A, B, C, D)> + Iterator, 

type Filter = ComponentTupleFilter<(A, B, C, D)>

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(A, B, C, D), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, A, B, C, D, E> ComponentLayout for ComponentTupleSet<(A, B, C, D, E), UWU> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    UWU: ExactSizeIterator<Item = (A, B, C, D, E)> + Iterator, 

type Filter = ComponentTupleFilter<(A, B, C, D, E)>

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(A, B, C, D, E), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, A, B, C, D, E, F> ComponentLayout for ComponentTupleSet<(A, B, C, D, E, F), UWU> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    UWU: ExactSizeIterator<Item = (A, B, C, D, E, F)> + Iterator, 

type Filter = ComponentTupleFilter<(A, B, C, D, E, F)>

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(A, B, C, D, E, F), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, A, B, C, D, E, F, G> ComponentLayout for ComponentTupleSet<(A, B, C, D, E, F, G), UWU> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    UWU: ExactSizeIterator<Item = (A, B, C, D, E, F, G)> + Iterator, 

type Filter = ComponentTupleFilter<(A, B, C, D, E, F, G)>

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(A, B, C, D, E, F, G), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, A, B, C, D, E, F, G, H> ComponentLayout for ComponentTupleSet<(A, B, C, D, E, F, G, H), UWU> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    UWU: ExactSizeIterator<Item = (A, B, C, D, E, F, G, H)> + Iterator, 

type Filter = ComponentTupleFilter<(A, B, C, D, E, F, G, H)>

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(A, B, C, D, E, F, G, H), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, A, B, C, D, E, F, G, H, I> ComponentLayout for ComponentTupleSet<(A, B, C, D, E, F, G, H, I), UWU> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    UWU: ExactSizeIterator<Item = (A, B, C, D, E, F, G, H, I)> + Iterator, 

type Filter = ComponentTupleFilter<(A, B, C, D, E, F, G, H, I)>

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(A, B, C, D, E, F, G, H, I), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, A, B, C, D, E, F, G, H, I, J> ComponentLayout for ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J), UWU> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    UWU: ExactSizeIterator<Item = (A, B, C, D, E, F, G, H, I, J)> + Iterator, 

type Filter = ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J)>

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, A, B, C, D, E, F, G, H, I, J, K> ComponentLayout for ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K), UWU> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    UWU: ExactSizeIterator<Item = (A, B, C, D, E, F, G, H, I, J, K)> + Iterator, 

type Filter = ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K)>

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, A, B, C, D, E, F, G, H, I, J, K, L> ComponentLayout for ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L), UWU> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    UWU: ExactSizeIterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)> + Iterator, 

type Filter = ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L)>

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, A, B, C, D, E, F, G, H, I, J, K, L, M> ComponentLayout for ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L, M), UWU> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    UWU: ExactSizeIterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L, M)> + Iterator, 

type Filter = ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M)>

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L, M), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, A, B, C, D, E, F, G, H, I, J, K, L, M, N> ComponentLayout for ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L, M, N), UWU> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component,
    UWU: ExactSizeIterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L, M, N)> + Iterator, 

type Filter = ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N)>

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L, M, N), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> ComponentLayout for ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), UWU> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component,
    O: Component,
    UWU: ExactSizeIterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)> + Iterator, 

type Filter = ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)>

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> ComponentLayout for ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), UWU> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component,
    O: Component,
    P: Component,
    UWU: ExactSizeIterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)> + Iterator, 

type Filter = ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)>

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> ComponentLayout for ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), UWU> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component,
    O: Component,
    P: Component,
    Q: Component,
    UWU: ExactSizeIterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)> + Iterator, 

type Filter = ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)>

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> ComponentLayout for ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), UWU> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component,
    O: Component,
    P: Component,
    Q: Component,
    R: Component,
    UWU: ExactSizeIterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)> + Iterator, 

type Filter = ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)>

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> ComponentLayout for ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), UWU> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component,
    O: Component,
    P: Component,
    Q: Component,
    R: Component,
    S: Component,
    UWU: ExactSizeIterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)> + Iterator, 

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

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> ComponentLayout for ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), UWU> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component,
    O: Component,
    P: Component,
    Q: Component,
    R: Component,
    S: Component,
    T: Component,
    UWU: ExactSizeIterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)> + Iterator, 

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

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> ComponentLayout for ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), UWU> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component,
    O: Component,
    P: Component,
    Q: Component,
    R: Component,
    S: Component,
    T: Component,
    U: Component,
    UWU: ExactSizeIterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)> + Iterator, 

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

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> ComponentLayout for ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), UWU> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component,
    O: Component,
    P: Component,
    Q: Component,
    R: Component,
    S: Component,
    T: Component,
    U: Component,
    UWU: ExactSizeIterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)> + Iterator,
    V: Component, 

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

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> ComponentLayout for ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W), UWU> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component,
    O: Component,
    P: Component,
    Q: Component,
    R: Component,
    S: Component,
    T: Component,
    U: Component,
    UWU: ExactSizeIterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)> + Iterator,
    V: Component,
    W: Component, 

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

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> ComponentLayout for ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X), UWU> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component,
    O: Component,
    P: Component,
    Q: Component,
    R: Component,
    S: Component,
    T: Component,
    U: Component,
    UWU: ExactSizeIterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)> + Iterator,
    V: Component,
    W: Component,
    X: Component, 

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

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, 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> ComponentLayout for ComponentTupleSet<(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), UWU> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component,
    O: Component,
    P: Component,
    Q: Component,
    R: Component,
    S: Component,
    T: Component,
    U: Component,
    UWU: ExactSizeIterator<Item = (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)> + Iterator,
    V: Component,
    W: Component,
    X: Component,
    Y: Component, 

type Filter = ComponentTupleFilter<(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)>

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(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), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<UWU, 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> ComponentLayout for ComponentTupleSet<(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), UWU> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component,
    O: Component,
    P: Component,
    Q: Component,
    R: Component,
    S: Component,
    T: Component,
    U: Component,
    UWU: ExactSizeIterator<Item = (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)> + Iterator,
    V: Component,
    W: Component,
    X: Component,
    Y: Component,
    Z: Component, 

type Filter = ComponentTupleFilter<(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)>

fn get_filter(
    &mut self
) -> &mut <ComponentTupleSet<(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), UWU> as ComponentLayout>::Filter

fn tailor_archetype(&self, archetype: &mut ArchetypeDescription)

Loading content...