Trait acute_ecs::world::TagLayout

pub trait TagLayout {
    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 tags 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 tags described by this layout.

Loading content...

Implementations on Foreign Types

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> TagLayout for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag,
    L: Tag,
    M: Tag,
    N: Tag,
    O: Tag,
    P: Tag,
    Q: Tag,
    R: Tag, 

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

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

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> TagLayout for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag,
    L: Tag,
    M: Tag,
    N: Tag,
    O: Tag,
    P: Tag,
    Q: Tag, 

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

fn get_filter(
    &mut self
) -> &mut (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)

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

impl<A, B, C, D, E, F, G> TagLayout for (A, B, C, D, E, F, G) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag, 

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

fn get_filter(&mut self) -> &mut (A, B, C, D, E, F, G)

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> TagLayout for (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: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag,
    L: Tag,
    M: Tag,
    N: Tag,
    O: Tag,
    P: Tag,
    Q: Tag,
    R: Tag,
    S: Tag,
    T: Tag,
    U: Tag,
    V: Tag,
    W: Tag, 

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

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

impl<A, B, C, D, E, F, G, H, I, J> TagLayout for (A, B, C, D, E, F, G, H, I, J) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag, 

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

fn get_filter(&mut self) -> &mut (A, B, C, D, E, F, G, H, I, J)

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> TagLayout for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag,
    L: Tag,
    M: Tag,
    N: Tag,
    O: Tag,
    P: Tag,
    Q: Tag,
    R: Tag,
    S: Tag,
    T: Tag,
    U: Tag,
    V: Tag, 

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

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> TagLayout for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag,
    L: Tag,
    M: Tag,
    N: Tag,
    O: Tag,
    P: Tag,
    Q: Tag,
    R: Tag,
    S: Tag,
    T: Tag, 

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

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

impl<A, B, C, D, E> TagLayout for (A, B, C, D, E) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag, 

type Filter = (A, B, C, D, E)

fn get_filter(&mut self) -> &mut (A, B, C, D, E)

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

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

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

fn get_filter(&mut self) -> &mut (A, B, C, D, E, F, G, H, I, J, K, L, M)

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

impl<A> TagLayout for (A,) where
    A: Tag, 

type Filter = (A,)

fn get_filter(&mut self) -> &mut (A,)

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

impl<A, B, C, D, E, F, G, H, I, J, K> TagLayout for (A, B, C, D, E, F, G, H, I, J, K) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag, 

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

fn get_filter(&mut self) -> &mut (A, B, C, D, E, F, G, H, I, J, K)

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> TagLayout for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag,
    L: Tag,
    M: Tag,
    N: Tag,
    O: Tag,
    P: Tag,
    Q: Tag,
    R: Tag,
    S: Tag,
    T: Tag,
    U: Tag, 

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

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

impl TagLayout for ()

type Filter = ()

fn get_filter(&mut self) -> &mut ()

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

impl<A, B, C, D, E, F, G, H> TagLayout for (A, B, C, D, E, F, G, H) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag, 

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

fn get_filter(&mut self) -> &mut (A, B, C, D, E, F, G, H)

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

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> TagLayout for (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: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag,
    L: Tag,
    M: Tag,
    N: Tag,
    O: Tag,
    P: Tag,
    Q: Tag,
    R: Tag,
    S: Tag,
    T: Tag,
    U: Tag,
    V: Tag,
    W: Tag,
    X: Tag,
    Y: Tag, 

type Filter = (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 (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 tailor_archetype(&self, archetype: &mut ArchetypeDescription)

impl<A, B, C, D, E, F> TagLayout for (A, B, C, D, E, F) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag, 

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

fn get_filter(&mut self) -> &mut (A, B, C, D, E, F)

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

impl<A, B, C, D, E, F, G, H, I> TagLayout for (A, B, C, D, E, F, G, H, I) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag, 

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

fn get_filter(&mut self) -> &mut (A, B, C, D, E, F, G, H, I)

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

impl<A, B, C> TagLayout for (A, B, C) where
    A: Tag,
    B: Tag,
    C: Tag, 

type Filter = (A, B, C)

fn get_filter(&mut self) -> &mut (A, B, C)

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

impl<A, B, C, D> TagLayout for (A, B, C, D) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag, 

type Filter = (A, B, C, D)

fn get_filter(&mut self) -> &mut (A, B, C, D)

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> TagLayout for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag,
    L: Tag,
    M: Tag,
    N: Tag,
    O: Tag,
    P: Tag,
    Q: Tag,
    R: Tag,
    S: Tag, 

type Filter = (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 (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

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

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> TagLayout for (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: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag,
    L: Tag,
    M: Tag,
    N: Tag,
    O: Tag,
    P: Tag,
    Q: Tag,
    R: Tag,
    S: Tag,
    T: Tag,
    U: Tag,
    V: Tag,
    W: Tag,
    X: Tag, 

type Filter = (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 (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 tailor_archetype(&self, archetype: &mut ArchetypeDescription)

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

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

fn get_filter(&mut self) -> &mut (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

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

impl<A, B, C, D, E, F, G, H, I, J, K, L> TagLayout for (A, B, C, D, E, F, G, H, I, J, K, L) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag,
    L: Tag, 

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

fn get_filter(&mut self) -> &mut (A, B, C, D, E, F, G, H, I, J, K, L)

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> TagLayout for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag,
    L: Tag,
    M: Tag,
    N: Tag,
    O: Tag,
    P: Tag, 

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

fn get_filter(
    &mut self
) -> &mut (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

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

impl<A, B> TagLayout for (A, B) where
    A: Tag,
    B: Tag, 

type Filter = (A, B)

fn get_filter(&mut self) -> &mut (A, B)

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

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

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

fn get_filter(&mut self) -> &mut (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

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

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> TagLayout for (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: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag,
    L: Tag,
    M: Tag,
    N: Tag,
    O: Tag,
    P: Tag,
    Q: Tag,
    R: Tag,
    S: Tag,
    T: Tag,
    U: Tag,
    V: Tag,
    W: Tag,
    X: Tag,
    Y: Tag,
    Z: Tag, 

type Filter = (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 (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 tailor_archetype(&self, archetype: &mut ArchetypeDescription)

Loading content...

Implementors

Loading content...