Trait oxygengine::prelude::AccessType

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

Provided Methods

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

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

([reads], [writes])

Implementations on Foreign Types

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, RandomState>, writes: &mut HashSet<TypeId, RandomState> )

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, RandomState>, writes: &mut HashSet<TypeId, RandomState> )

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, RandomState>, writes: &mut HashSet<TypeId, RandomState> )

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, RandomState>, writes: &mut HashSet<TypeId, RandomState> )

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

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

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, RandomState>, writes: &mut HashSet<TypeId, RandomState> )

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, RandomState>, writes: &mut HashSet<TypeId, RandomState> )

impl AccessType for ()

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

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

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

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

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

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

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, RandomState>, writes: &mut HashSet<TypeId, RandomState> )

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, RandomState>, writes: &mut HashSet<TypeId, RandomState> )

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, RandomState>, writes: &mut HashSet<TypeId, RandomState> )

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, RandomState>, writes: &mut HashSet<TypeId, RandomState> )

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, RandomState>, writes: &mut HashSet<TypeId, RandomState> )

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, RandomState>, writes: &mut HashSet<TypeId, RandomState> )

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

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

Implementors

impl AccessType for WorldRef

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