Trait bevy_ecs::Fetch

pub trait Fetch<'a> {
    type Item;
    fn access(archetype: &Archetype) -> Option<Access>;
    fn borrow(archetype: &Archetype);
    unsafe fn get(archetype: &'a Archetype, offset: usize) -> Option<Self>;
    fn release(archetype: &Archetype);
    unsafe fn next(&mut self) -> Self::Item;

    unsafe fn should_skip(&self) -> bool { ... }
}

Streaming iterators over contiguous homogeneous ranges of components

Associated Types

type Item

Type of value to be fetched

Loading content...

Required methods

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

How this query will access archetype, if at all

fn borrow(archetype: &Archetype)

Acquire dynamic borrows from archetype

unsafe fn get(archetype: &'a Archetype, offset: usize) -> Option<Self>

Construct a Fetch for archetype if it should be traversed

Safety

offset must be in bounds of archetype

fn release(archetype: &Archetype)

Release dynamic borrows acquired by borrow

unsafe fn next(&mut self) -> Self::Item

Access the next item in this archetype without bounds checking

Safety

• Must only be called after borrow
• release must not be called while 'a is still live
• Bounds-checking must be performed externally
• Any resulting borrows must be legal (e.g. no &mut to something another iterator might access)

Loading content...

Provided methods

unsafe fn should_skip(&self) -> bool

if this returns true, the current item will be skipped during iteration

Safety

shouldn't be called if there is no current item

Loading content...

Implementations on Foreign Types

impl<'a, B, A> Fetch<'a> for (B, A) where
    A: Fetch<'a>,
    B: Fetch<'a>, 

type Item = (<B as Fetch<'a>>::Item, <A as Fetch<'a>>::Item)

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

fn borrow(archetype: &Archetype)

unsafe fn get(archetype: &'a Archetype, offset: usize) -> Option<(B, A)>

fn release(archetype: &Archetype)

unsafe fn next(&mut self) -> <(B, A) as Fetch<'a>>::Item

unsafe fn should_skip(&self) -> bool

impl<'a, C, B, A> Fetch<'a> for (C, B, A) where
    A: Fetch<'a>,
    B: Fetch<'a>,
    C: Fetch<'a>, 

type Item = (<C as Fetch<'a>>::Item, <B as Fetch<'a>>::Item, <A as Fetch<'a>>::Item)

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

fn borrow(archetype: &Archetype)

unsafe fn get(archetype: &'a Archetype, offset: usize) -> Option<(C, B, A)>

fn release(archetype: &Archetype)

unsafe fn next(&mut self) -> <(C, B, A) as Fetch<'a>>::Item

unsafe fn should_skip(&self) -> bool

impl<'a, E, D, C, B, A> Fetch<'a> for (E, D, C, B, A) where
    A: Fetch<'a>,
    B: Fetch<'a>,
    C: Fetch<'a>,
    D: Fetch<'a>,
    E: Fetch<'a>, 

type Item = (<E as Fetch<'a>>::Item, <D as Fetch<'a>>::Item, <C as Fetch<'a>>::Item, <B as Fetch<'a>>::Item, <A as Fetch<'a>>::Item)

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

fn borrow(archetype: &Archetype)

unsafe fn get(
    archetype: &'a Archetype,
    offset: usize
) -> Option<(E, D, C, B, A)>

fn release(archetype: &Archetype)

unsafe fn next(&mut self) -> <(E, D, C, B, A) as Fetch<'a>>::Item

unsafe fn should_skip(&self) -> bool

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

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

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

fn borrow(archetype: &Archetype)

unsafe fn get(
    archetype: &'a Archetype,
    offset: usize
) -> Option<(M, L, K, J, I, H, G, F, E, D, C, B, A)>

fn release(archetype: &Archetype)

unsafe fn next(
    &mut self
) -> <(M, L, K, J, I, H, G, F, E, D, C, B, A) as Fetch<'a>>::Item

unsafe fn should_skip(&self) -> bool

impl<'a, F, E, D, C, B, A> Fetch<'a> for (F, E, D, C, B, A) where
    A: Fetch<'a>,
    B: Fetch<'a>,
    C: Fetch<'a>,
    D: Fetch<'a>,
    E: Fetch<'a>,
    F: Fetch<'a>, 

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

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

fn borrow(archetype: &Archetype)

unsafe fn get(
    archetype: &'a Archetype,
    offset: usize
) -> Option<(F, E, D, C, B, A)>

fn release(archetype: &Archetype)

unsafe fn next(&mut self) -> <(F, E, D, C, B, A) as Fetch<'a>>::Item

unsafe fn should_skip(&self) -> bool

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

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

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

fn borrow(archetype: &Archetype)

unsafe fn get(
    archetype: &'a Archetype,
    offset: usize
) -> Option<(L, K, J, I, H, G, F, E, D, C, B, A)>

fn release(archetype: &Archetype)

unsafe fn next(
    &mut self
) -> <(L, K, J, I, H, G, F, E, D, C, B, A) as Fetch<'a>>::Item

unsafe fn should_skip(&self) -> bool

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

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

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

fn borrow(archetype: &Archetype)

unsafe fn get(
    archetype: &'a Archetype,
    offset: usize
) -> Option<(N, M, L, K, J, I, H, G, F, E, D, C, B, A)>

fn release(archetype: &Archetype)

unsafe fn next(
    &mut self
) -> <(N, M, L, K, J, I, H, G, F, E, D, C, B, A) as Fetch<'a>>::Item

unsafe fn should_skip(&self) -> bool

impl<'a, A> Fetch<'a> for (A,) where
    A: Fetch<'a>, 

type Item = (<A as Fetch<'a>>::Item,)

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

fn borrow(archetype: &Archetype)

unsafe fn get(archetype: &'a Archetype, offset: usize) -> Option<(A,)>

fn release(archetype: &Archetype)

unsafe fn next(&mut self) -> <(A,) as Fetch<'a>>::Item

unsafe fn should_skip(&self) -> bool

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

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

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

fn borrow(archetype: &Archetype)

unsafe fn get(
    archetype: &'a Archetype,
    offset: usize
) -> Option<(O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)>

fn release(archetype: &Archetype)

unsafe fn next(
    &mut self
) -> <(O, N, M, L, K, J, I, H, G, F, E, D, C, B, A) as Fetch<'a>>::Item

unsafe fn should_skip(&self) -> bool

impl<'a> Fetch<'a> for ()

type Item = ()

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

fn borrow(archetype: &Archetype)

unsafe fn get(archetype: &'a Archetype, offset: usize) -> Option<()>

fn release(archetype: &Archetype)

unsafe fn next(&mut self) -> <() as Fetch<'a>>::Item

unsafe fn should_skip(&self) -> bool

impl<'a, D, C, B, A> Fetch<'a> for (D, C, B, A) where
    A: Fetch<'a>,
    B: Fetch<'a>,
    C: Fetch<'a>,
    D: Fetch<'a>, 

type Item = (<D as Fetch<'a>>::Item, <C as Fetch<'a>>::Item, <B as Fetch<'a>>::Item, <A as Fetch<'a>>::Item)

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

fn borrow(archetype: &Archetype)

unsafe fn get(archetype: &'a Archetype, offset: usize) -> Option<(D, C, B, A)>

fn release(archetype: &Archetype)

unsafe fn next(&mut self) -> <(D, C, B, A) as Fetch<'a>>::Item

unsafe fn should_skip(&self) -> bool

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

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

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

fn borrow(archetype: &Archetype)

unsafe fn get(
    archetype: &'a Archetype,
    offset: usize
) -> Option<(I, H, G, F, E, D, C, B, A)>

fn release(archetype: &Archetype)

unsafe fn next(&mut self) -> <(I, H, G, F, E, D, C, B, A) as Fetch<'a>>::Item

unsafe fn should_skip(&self) -> bool

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

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

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

fn borrow(archetype: &Archetype)

unsafe fn get(
    archetype: &'a Archetype,
    offset: usize
) -> Option<(J, I, H, G, F, E, D, C, B, A)>

fn release(archetype: &Archetype)

unsafe fn next(&mut self) -> <(J, I, H, G, F, E, D, C, B, A) as Fetch<'a>>::Item

unsafe fn should_skip(&self) -> bool

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

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

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

fn borrow(archetype: &Archetype)

unsafe fn get(
    archetype: &'a Archetype,
    offset: usize
) -> Option<(K, J, I, H, G, F, E, D, C, B, A)>

fn release(archetype: &Archetype)

unsafe fn next(
    &mut self
) -> <(K, J, I, H, G, F, E, D, C, B, A) as Fetch<'a>>::Item

unsafe fn should_skip(&self) -> bool

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

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

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

fn borrow(archetype: &Archetype)

unsafe fn get(
    archetype: &'a Archetype,
    offset: usize
) -> Option<(G, F, E, D, C, B, A)>

fn release(archetype: &Archetype)

unsafe fn next(&mut self) -> <(G, F, E, D, C, B, A) as Fetch<'a>>::Item

unsafe fn should_skip(&self) -> bool

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

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

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

fn borrow(archetype: &Archetype)

unsafe fn get(
    archetype: &'a Archetype,
    offset: usize
) -> Option<(H, G, F, E, D, C, B, A)>

fn release(archetype: &Archetype)

unsafe fn next(&mut self) -> <(H, G, F, E, D, C, B, A) as Fetch<'a>>::Item

unsafe fn should_skip(&self) -> bool

Loading content...

Implementors

Loading content...