Trait pyro::AppendComponents

pub trait AppendComponentswhere
    Self: IteratorSoa,{
    fn is_match<S: Storage>(storage: &S) -> bool;
    fn append_components<I, S>(items: I, storage: &mut S) -> usize
    where
        S: Storage,
        I: IntoIterator<Item = Self>;
}

Required Methods

fn is_match<S: Storage>(storage: &S) -> bool

fn append_components<I, S>(items: I, storage: &mut S) -> usizewhere
    S: Storage,
    I: IntoIterator<Item = Self>,

Implementations on Foreign Types

impl<A> AppendComponents for (A,)where
    A: Component,

fn is_match<S: Storage>(storage: &S) -> bool

fn append_components<Iter, S>(items: Iter, storage: &mut S) -> usizewhere
    S: Storage,
    Iter: IntoIterator<Item = Self>,

impl<A, B> AppendComponents for (A, B)where
    A: Component,
    B: Component,

fn is_match<S: Storage>(storage: &S) -> bool

fn append_components<Iter, S>(items: Iter, storage: &mut S) -> usizewhere
    S: Storage,
    Iter: IntoIterator<Item = Self>,

impl<A, B, C> AppendComponents for (A, B, C)where
    A: Component,
    B: Component,
    C: Component,

fn is_match<S: Storage>(storage: &S) -> bool

fn append_components<Iter, S>(items: Iter, storage: &mut S) -> usizewhere
    S: Storage,
    Iter: IntoIterator<Item = Self>,

impl<A, B, C, D> AppendComponents for (A, B, C, D)where
    A: Component,
    B: Component,
    C: Component,
    D: Component,

fn is_match<S: Storage>(storage: &S) -> bool

fn append_components<Iter, S>(items: Iter, storage: &mut S) -> usizewhere
    S: Storage,
    Iter: IntoIterator<Item = Self>,

impl<A, B, C, D, E> AppendComponents for (A, B, C, D, E)where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,

fn is_match<S: Storage>(storage: &S) -> bool

fn append_components<Iter, S>(items: Iter, storage: &mut S) -> usizewhere
    S: Storage,
    Iter: IntoIterator<Item = Self>,

impl<A, B, C, D, E, F> AppendComponents for (A, B, C, D, E, F)where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,

fn is_match<S: Storage>(storage: &S) -> bool

fn append_components<Iter, S>(items: Iter, storage: &mut S) -> usizewhere
    S: Storage,
    Iter: IntoIterator<Item = Self>,

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

fn is_match<S: Storage>(storage: &S) -> bool

fn append_components<Iter, S>(items: Iter, storage: &mut S) -> usizewhere
    S: Storage,
    Iter: IntoIterator<Item = Self>,

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

fn is_match<S: Storage>(storage: &S) -> bool

fn append_components<Iter, S>(items: Iter, storage: &mut S) -> usizewhere
    S: Storage,
    Iter: IntoIterator<Item = Self>,

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

fn is_match<S: Storage>(storage: &S) -> bool

fn append_components<Iter, S>(items: Iter, storage: &mut S) -> usizewhere
    S: Storage,
    Iter: IntoIterator<Item = Self>,

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

fn is_match<S: Storage>(storage: &S) -> bool

fn append_components<Iter, S>(items: Iter, storage: &mut S) -> usizewhere
    S: Storage,
    Iter: IntoIterator<Item = Self>,

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

fn is_match<S: Storage>(storage: &S) -> bool

fn append_components<Iter, S>(items: Iter, storage: &mut S) -> usizewhere
    S: Storage,
    Iter: IntoIterator<Item = Self>,

Implementors