Trait oxygengine_core::ecs::AccessType

pub trait AccessType {
    fn feed_types(_reads: &mut HashSet<TypeId>, _writes: &mut HashSet<TypeId>) { ... }
    fn get_types() -> (HashSet<TypeId>, HashSet<TypeId>) { ... }
}

Provided methods

fn feed_types(_reads: &mut HashSet<TypeId>, _writes: &mut HashSet<TypeId>)

fn get_types() -> (HashSet<TypeId>, HashSet<TypeId>)

([reads], [writes])

Implementations on Foreign Types

impl AccessType for ()

impl<T> AccessType for &T where
    T: 'static, 

fn feed_types(reads: &mut HashSet<TypeId>, _: &mut HashSet<TypeId>)

impl<T> AccessType for &mut T where
    T: 'static, 

fn feed_types(_: &mut HashSet<TypeId>, writes: &mut HashSet<TypeId>)

impl<A> AccessType for (A,) where
    A: AccessType, 

fn feed_types(reads: &mut HashSet<TypeId>, writes: &mut HashSet<TypeId>)

impl<A, B> AccessType for (A, B) where
    A: AccessType,
    B: AccessType, 

fn feed_types(reads: &mut HashSet<TypeId>, writes: &mut HashSet<TypeId>)

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

fn feed_types(reads: &mut HashSet<TypeId>, writes: &mut HashSet<TypeId>)

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

fn feed_types(reads: &mut HashSet<TypeId>, writes: &mut HashSet<TypeId>)

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

fn feed_types(reads: &mut HashSet<TypeId>, writes: &mut HashSet<TypeId>)

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

fn feed_types(reads: &mut HashSet<TypeId>, writes: &mut HashSet<TypeId>)

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

fn feed_types(reads: &mut HashSet<TypeId>, writes: &mut HashSet<TypeId>)

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

fn feed_types(reads: &mut HashSet<TypeId>, writes: &mut HashSet<TypeId>)

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

fn feed_types(reads: &mut HashSet<TypeId>, writes: &mut HashSet<TypeId>)

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

fn feed_types(reads: &mut HashSet<TypeId>, writes: &mut HashSet<TypeId>)

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

fn feed_types(reads: &mut HashSet<TypeId>, writes: &mut HashSet<TypeId>)

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

fn feed_types(reads: &mut HashSet<TypeId>, writes: &mut HashSet<TypeId>)

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

fn feed_types(reads: &mut HashSet<TypeId>, writes: &mut HashSet<TypeId>)

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

fn feed_types(reads: &mut HashSet<TypeId>, writes: &mut HashSet<TypeId>)

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

fn feed_types(reads: &mut HashSet<TypeId>, writes: &mut HashSet<TypeId>)

Implementors

impl AccessType for WorldRef

impl<T> AccessType for Comp<T> where
    T: AccessType,