Trait Fetch

pub unsafe trait Fetch: Sized + Clone {
    type State: Copy;

    // Required methods
    fn dangling() -> Self;
    fn access(archetype: &Archetype) -> Option<Access>;
    fn borrow(archetype: &Archetype, state: Self::State);
    fn prepare(archetype: &Archetype) -> Option<Self::State>;
    fn execute(archetype: &Archetype, state: Self::State) -> Self;
    fn release(archetype: &Archetype, state: Self::State);
    fn for_each_borrow(f: impl FnMut(TypeId, bool));
}

Streaming iterators over contiguous homogeneous ranges of components

Required Associated Types

type State: Copy

The type of the data which can be cached to speed up retrieving the relevant type states from a matching Archetype

Required Methods

fn dangling() -> Self

A value on which get may never be called

fn access(archetype: &Archetype) -> Option<Access>

How this query will access archetype, if at all

fn borrow(archetype: &Archetype, state: Self::State)

Acquire dynamic borrows from archetype

fn prepare(archetype: &Archetype) -> Option<Self::State>

Look up state for archetype if it should be traversed

fn execute(archetype: &Archetype, state: Self::State) -> Self

Construct a Fetch for archetype based on the associated state

fn release(archetype: &Archetype, state: Self::State)

Release dynamic borrows acquired by borrow

fn for_each_borrow(f: impl FnMut(TypeId, bool))

Invoke f for every component type that may be borrowed and whether the borrow is unique

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Fetch for ()

type State = ()

fn dangling()

fn access(archetype: &Archetype) -> Option<Access>

fn borrow(archetype: &Archetype, state: <() as Fetch>::State)

fn prepare(archetype: &Archetype) -> Option<<() as Fetch>::State>

fn execute(archetype: &Archetype, state: <() as Fetch>::State)

fn release(archetype: &Archetype, state: <() as Fetch>::State)

fn for_each_borrow(f: impl FnMut(TypeId, bool))

impl<A> Fetch for (A,)

where A: Fetch,

type State = (<A as Fetch>::State,)

fn dangling() -> (A,)

fn access(archetype: &Archetype) -> Option<Access>

fn borrow(archetype: &Archetype, state: <(A,) as Fetch>::State)

fn prepare(archetype: &Archetype) -> Option<<(A,) as Fetch>::State>

fn execute(archetype: &Archetype, state: <(A,) as Fetch>::State) -> (A,)

fn release(archetype: &Archetype, state: <(A,) as Fetch>::State)

fn for_each_borrow(f: impl FnMut(TypeId, bool))

impl<A, B> Fetch for (A, B)

where A: Fetch, B: Fetch,

type State = (<A as Fetch>::State, <B as Fetch>::State)

fn dangling() -> (A, B)

fn access(archetype: &Archetype) -> Option<Access>

fn borrow(archetype: &Archetype, state: <(A, B) as Fetch>::State)

fn prepare(archetype: &Archetype) -> Option<<(A, B) as Fetch>::State>

fn execute(archetype: &Archetype, state: <(A, B) as Fetch>::State) -> (A, B)

fn release(archetype: &Archetype, state: <(A, B) as Fetch>::State)

fn for_each_borrow(f: impl FnMut(TypeId, bool))

impl<A, B, C> Fetch for (A, B, C)

where A: Fetch, B: Fetch, C: Fetch,

type State = (<A as Fetch>::State, <B as Fetch>::State, <C as Fetch>::State)

fn dangling() -> (A, B, C)

fn access(archetype: &Archetype) -> Option<Access>

fn borrow(archetype: &Archetype, state: <(A, B, C) as Fetch>::State)

fn prepare(archetype: &Archetype) -> Option<<(A, B, C) as Fetch>::State>

fn execute( archetype: &Archetype, state: <(A, B, C) as Fetch>::State, ) -> (A, B, C)

fn release(archetype: &Archetype, state: <(A, B, C) as Fetch>::State)

fn for_each_borrow(f: impl FnMut(TypeId, bool))

impl<A, B, C, D> Fetch for (A, B, C, D)

where A: Fetch, B: Fetch, C: Fetch, D: Fetch,

type State = (<A as Fetch>::State, <B as Fetch>::State, <C as Fetch>::State, <D as Fetch>::State)

fn dangling() -> (A, B, C, D)

fn access(archetype: &Archetype) -> Option<Access>

fn borrow(archetype: &Archetype, state: <(A, B, C, D) as Fetch>::State)

fn prepare(archetype: &Archetype) -> Option<<(A, B, C, D) as Fetch>::State>

fn execute( archetype: &Archetype, state: <(A, B, C, D) as Fetch>::State, ) -> (A, B, C, D)

fn release(archetype: &Archetype, state: <(A, B, C, D) as Fetch>::State)

fn for_each_borrow(f: impl FnMut(TypeId, bool))

impl<A, B, C, D, E> Fetch for (A, B, C, D, E)

where A: Fetch, B: Fetch, C: Fetch, D: Fetch, E: Fetch,

type State = (<A as Fetch>::State, <B as Fetch>::State, <C as Fetch>::State, <D as Fetch>::State, <E as Fetch>::State)

fn dangling() -> (A, B, C, D, E)

fn access(archetype: &Archetype) -> Option<Access>

fn borrow(archetype: &Archetype, state: <(A, B, C, D, E) as Fetch>::State)

fn prepare(archetype: &Archetype) -> Option<<(A, B, C, D, E) as Fetch>::State>

fn execute( archetype: &Archetype, state: <(A, B, C, D, E) as Fetch>::State, ) -> (A, B, C, D, E)

fn release(archetype: &Archetype, state: <(A, B, C, D, E) as Fetch>::State)

fn for_each_borrow(f: impl FnMut(TypeId, bool))

impl<A, B, C, D, E, F> Fetch for (A, B, C, D, E, F)

where A: Fetch, B: Fetch, C: Fetch, D: Fetch, E: Fetch, F: Fetch,

type State = (<A as Fetch>::State, <B as Fetch>::State, <C as Fetch>::State, <D as Fetch>::State, <E as Fetch>::State, <F as Fetch>::State)

fn dangling() -> (A, B, C, D, E, F)

fn access(archetype: &Archetype) -> Option<Access>

fn borrow(archetype: &Archetype, state: <(A, B, C, D, E, F) as Fetch>::State)

fn prepare( archetype: &Archetype, ) -> Option<<(A, B, C, D, E, F) as Fetch>::State>

fn execute( archetype: &Archetype, state: <(A, B, C, D, E, F) as Fetch>::State, ) -> (A, B, C, D, E, F)

fn release(archetype: &Archetype, state: <(A, B, C, D, E, F) as Fetch>::State)

fn for_each_borrow(f: impl FnMut(TypeId, bool))

impl<A, B, C, D, E, F, G> Fetch for (A, B, C, D, E, F, G)

where A: Fetch, B: Fetch, C: Fetch, D: Fetch, E: Fetch, F: Fetch, G: Fetch,

type State = (<A as Fetch>::State, <B as Fetch>::State, <C as Fetch>::State, <D as Fetch>::State, <E as Fetch>::State, <F as Fetch>::State, <G as Fetch>::State)

fn dangling() -> (A, B, C, D, E, F, G)

fn access(archetype: &Archetype) -> Option<Access>

fn borrow(archetype: &Archetype, state: <(A, B, C, D, E, F, G) as Fetch>::State)

fn prepare( archetype: &Archetype, ) -> Option<<(A, B, C, D, E, F, G) as Fetch>::State>

fn execute( archetype: &Archetype, state: <(A, B, C, D, E, F, G) as Fetch>::State, ) -> (A, B, C, D, E, F, G)

fn release( archetype: &Archetype, state: <(A, B, C, D, E, F, G) as Fetch>::State, )

fn for_each_borrow(f: impl FnMut(TypeId, bool))

impl<A, B, C, D, E, F, G, H> Fetch for (A, B, C, D, E, F, G, H)

where A: Fetch, B: Fetch, C: Fetch, D: Fetch, E: Fetch, F: Fetch, G: Fetch, H: Fetch,

type State = (<A as Fetch>::State, <B as Fetch>::State, <C as Fetch>::State, <D as Fetch>::State, <E as Fetch>::State, <F as Fetch>::State, <G as Fetch>::State, <H as Fetch>::State)

fn dangling() -> (A, B, C, D, E, F, G, H)

fn access(archetype: &Archetype) -> Option<Access>

fn borrow( archetype: &Archetype, state: <(A, B, C, D, E, F, G, H) as Fetch>::State, )

fn prepare( archetype: &Archetype, ) -> Option<<(A, B, C, D, E, F, G, H) as Fetch>::State>

fn execute( archetype: &Archetype, state: <(A, B, C, D, E, F, G, H) as Fetch>::State, ) -> (A, B, C, D, E, F, G, H)

fn release( archetype: &Archetype, state: <(A, B, C, D, E, F, G, H) as Fetch>::State, )

fn for_each_borrow(f: impl FnMut(TypeId, bool))

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

where A: Fetch, B: Fetch, C: Fetch, D: Fetch, E: Fetch, F: Fetch, G: Fetch, H: Fetch, I: Fetch,

type State = (<A as Fetch>::State, <B as Fetch>::State, <C as Fetch>::State, <D as Fetch>::State, <E as Fetch>::State, <F as Fetch>::State, <G as Fetch>::State, <H as Fetch>::State, <I as Fetch>::State)

fn dangling() -> (A, B, C, D, E, F, G, H, I)

fn access(archetype: &Archetype) -> Option<Access>

fn borrow( archetype: &Archetype, state: <(A, B, C, D, E, F, G, H, I) as Fetch>::State, )

fn prepare( archetype: &Archetype, ) -> Option<<(A, B, C, D, E, F, G, H, I) as Fetch>::State>

fn execute( archetype: &Archetype, state: <(A, B, C, D, E, F, G, H, I) as Fetch>::State, ) -> (A, B, C, D, E, F, G, H, I)

fn release( archetype: &Archetype, state: <(A, B, C, D, E, F, G, H, I) as Fetch>::State, )

fn for_each_borrow(f: impl FnMut(TypeId, bool))

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

where A: Fetch, B: Fetch, C: Fetch, D: Fetch, E: Fetch, F: Fetch, G: Fetch, H: Fetch, I: Fetch, J: Fetch,

type State = (<A as Fetch>::State, <B as Fetch>::State, <C as Fetch>::State, <D as Fetch>::State, <E as Fetch>::State, <F as Fetch>::State, <G as Fetch>::State, <H as Fetch>::State, <I as Fetch>::State, <J as Fetch>::State)

fn dangling() -> (A, B, C, D, E, F, G, H, I, J)

fn access(archetype: &Archetype) -> Option<Access>

fn borrow( archetype: &Archetype, state: <(A, B, C, D, E, F, G, H, I, J) as Fetch>::State, )

fn prepare( archetype: &Archetype, ) -> Option<<(A, B, C, D, E, F, G, H, I, J) as Fetch>::State>

fn execute( archetype: &Archetype, state: <(A, B, C, D, E, F, G, H, I, J) as Fetch>::State, ) -> (A, B, C, D, E, F, G, H, I, J)

fn release( archetype: &Archetype, state: <(A, B, C, D, E, F, G, H, I, J) as Fetch>::State, )

fn for_each_borrow(f: impl FnMut(TypeId, bool))

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

where A: Fetch, B: Fetch, C: Fetch, D: Fetch, E: Fetch, F: Fetch, G: Fetch, H: Fetch, I: Fetch, J: Fetch, K: Fetch,

type State = (<A as Fetch>::State, <B as Fetch>::State, <C as Fetch>::State, <D as Fetch>::State, <E as Fetch>::State, <F as Fetch>::State, <G as Fetch>::State, <H as Fetch>::State, <I as Fetch>::State, <J as Fetch>::State, <K as Fetch>::State)

fn dangling() -> (A, B, C, D, E, F, G, H, I, J, K)

fn access(archetype: &Archetype) -> Option<Access>

fn borrow( archetype: &Archetype, state: <(A, B, C, D, E, F, G, H, I, J, K) as Fetch>::State, )

fn prepare( archetype: &Archetype, ) -> Option<<(A, B, C, D, E, F, G, H, I, J, K) as Fetch>::State>

fn execute( archetype: &Archetype, state: <(A, B, C, D, E, F, G, H, I, J, K) as Fetch>::State, ) -> (A, B, C, D, E, F, G, H, I, J, K)

fn release( archetype: &Archetype, state: <(A, B, C, D, E, F, G, H, I, J, K) as Fetch>::State, )

fn for_each_borrow(f: impl FnMut(TypeId, bool))

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

where A: Fetch, B: Fetch, C: Fetch, D: Fetch, E: Fetch, F: Fetch, G: Fetch, H: Fetch, I: Fetch, J: Fetch, K: Fetch, L: Fetch,

type State = (<A as Fetch>::State, <B as Fetch>::State, <C as Fetch>::State, <D as Fetch>::State, <E as Fetch>::State, <F as Fetch>::State, <G as Fetch>::State, <H as Fetch>::State, <I as Fetch>::State, <J as Fetch>::State, <K as Fetch>::State, <L as Fetch>::State)

fn dangling() -> (A, B, C, D, E, F, G, H, I, J, K, L)

fn access(archetype: &Archetype) -> Option<Access>

fn borrow( archetype: &Archetype, state: <(A, B, C, D, E, F, G, H, I, J, K, L) as Fetch>::State, )

fn prepare( archetype: &Archetype, ) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L) as Fetch>::State>

fn execute( archetype: &Archetype, state: <(A, B, C, D, E, F, G, H, I, J, K, L) as Fetch>::State, ) -> (A, B, C, D, E, F, G, H, I, J, K, L)

fn release( archetype: &Archetype, state: <(A, B, C, D, E, F, G, H, I, J, K, L) as Fetch>::State, )

fn for_each_borrow(f: impl FnMut(TypeId, bool))

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

where A: Fetch, B: Fetch, C: Fetch, D: Fetch, E: Fetch, F: Fetch, G: Fetch, H: Fetch, I: Fetch, J: Fetch, K: Fetch, L: Fetch, M: Fetch,

type State = (<A as Fetch>::State, <B as Fetch>::State, <C as Fetch>::State, <D as Fetch>::State, <E as Fetch>::State, <F as Fetch>::State, <G as Fetch>::State, <H as Fetch>::State, <I as Fetch>::State, <J as Fetch>::State, <K as Fetch>::State, <L as Fetch>::State, <M as Fetch>::State)

fn dangling() -> (A, B, C, D, E, F, G, H, I, J, K, L, M)

fn access(archetype: &Archetype) -> Option<Access>

fn borrow( archetype: &Archetype, state: <(A, B, C, D, E, F, G, H, I, J, K, L, M) as Fetch>::State, )

fn prepare( archetype: &Archetype, ) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M) as Fetch>::State>

fn execute( archetype: &Archetype, state: <(A, B, C, D, E, F, G, H, I, J, K, L, M) as Fetch>::State, ) -> (A, B, C, D, E, F, G, H, I, J, K, L, M)

fn release( archetype: &Archetype, state: <(A, B, C, D, E, F, G, H, I, J, K, L, M) as Fetch>::State, )

fn for_each_borrow(f: impl FnMut(TypeId, bool))

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

where A: Fetch, B: Fetch, C: Fetch, D: Fetch, E: Fetch, F: Fetch, G: Fetch, H: Fetch, I: Fetch, J: Fetch, K: Fetch, L: Fetch, M: Fetch, N: Fetch,

type State = (<A as Fetch>::State, <B as Fetch>::State, <C as Fetch>::State, <D as Fetch>::State, <E as Fetch>::State, <F as Fetch>::State, <G as Fetch>::State, <H as Fetch>::State, <I as Fetch>::State, <J as Fetch>::State, <K as Fetch>::State, <L as Fetch>::State, <M as Fetch>::State, <N as Fetch>::State)

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

fn access(archetype: &Archetype) -> Option<Access>

fn borrow( archetype: &Archetype, state: <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as Fetch>::State, )

fn prepare( archetype: &Archetype, ) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as Fetch>::State>

fn execute( archetype: &Archetype, state: <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as Fetch>::State, ) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

fn release( archetype: &Archetype, state: <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as Fetch>::State, )

fn for_each_borrow(f: impl FnMut(TypeId, bool))

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

where A: Fetch, B: Fetch, C: Fetch, D: Fetch, E: Fetch, F: Fetch, G: Fetch, H: Fetch, I: Fetch, J: Fetch, K: Fetch, L: Fetch, M: Fetch, N: Fetch, O: Fetch,

type State = (<A as Fetch>::State, <B as Fetch>::State, <C as Fetch>::State, <D as Fetch>::State, <E as Fetch>::State, <F as Fetch>::State, <G as Fetch>::State, <H as Fetch>::State, <I as Fetch>::State, <J as Fetch>::State, <K as Fetch>::State, <L as Fetch>::State, <M as Fetch>::State, <N as Fetch>::State, <O as Fetch>::State)

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

fn access(archetype: &Archetype) -> Option<Access>

fn borrow( archetype: &Archetype, state: <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as Fetch>::State, )

fn prepare( archetype: &Archetype, ) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as Fetch>::State>

fn execute( archetype: &Archetype, state: <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as Fetch>::State, ) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

fn release( archetype: &Archetype, state: <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as Fetch>::State, )

fn for_each_borrow(f: impl FnMut(TypeId, bool))

Implementors