Trait hobo::query::Query

pub trait Query {
    type Fetch;

    // Required method
    fn fetch(world: &World, entity: Entity) -> Self::Fetch;

    // Provided method
    fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>) { ... }
}

Required Associated Types

type Fetch

Required Methods

fn fetch(world: &World, entity: Entity) -> Self::Fetch

Provided Methods

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

Implementations on Foreign Types

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

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

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

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

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

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

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

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

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

impl<A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, G: Query, H: Query, I: Query, J: Query, K: Query, L: Query, M: Query, N: Query, O: Query, P: Query, Q: Query, R: Query, S: Query, T: Query, U: Query, V: Query, W: Query> Query for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)

type Fetch = (<A as Query>::Fetch, <B as Query>::Fetch, <C as Query>::Fetch, <D as Query>::Fetch, <E as Query>::Fetch, <F as Query>::Fetch, <G as Query>::Fetch, <H as Query>::Fetch, <I as Query>::Fetch, <J as Query>::Fetch, <K as Query>::Fetch, <L as Query>::Fetch, <M as Query>::Fetch, <N as Query>::Fetch, <O as Query>::Fetch, <P as Query>::Fetch, <Q as Query>::Fetch, <R as Query>::Fetch, <S as Query>::Fetch, <T as Query>::Fetch, <U as Query>::Fetch, <V as Query>::Fetch, <W as Query>::Fetch)

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

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

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

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

impl<Component: 'static> Query for &Component

type Fetch = OwningRef<Box<dyn Erased, Global>, Component>

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

impl<A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, G: Query, H: Query, I: Query, J: Query, K: Query, L: Query, M: Query, N: Query, O: Query, P: Query, Q: Query, R: Query, S: Query> Query for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

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

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

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

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

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

impl<A: Query, B: Query, C: Query> Query for (A, B, C)

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

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

impl<A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, G: Query, H: Query, I: Query, J: Query, K: Query, L: Query, M: Query, N: Query, O: Query, P: Query, Q: Query, R: Query, S: Query, T: Query, U: Query, V: Query, W: Query, X: Query, Y: Query, Z: Query> Query for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

type Fetch = (<A as Query>::Fetch, <B as Query>::Fetch, <C as Query>::Fetch, <D as Query>::Fetch, <E as Query>::Fetch, <F as Query>::Fetch, <G as Query>::Fetch, <H as Query>::Fetch, <I as Query>::Fetch, <J as Query>::Fetch, <K as Query>::Fetch, <L as Query>::Fetch, <M as Query>::Fetch, <N as Query>::Fetch, <O as Query>::Fetch, <P as Query>::Fetch, <Q as Query>::Fetch, <R as Query>::Fetch, <S as Query>::Fetch, <T as Query>::Fetch, <U as Query>::Fetch, <V as Query>::Fetch, <W as Query>::Fetch, <X as Query>::Fetch, <Y as Query>::Fetch, <Z as Query>::Fetch)

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

impl<Component: 'static> Query for &mut Component

type Fetch = OwningRefMut<Box<dyn Erased, Global>, Component>

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

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

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

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

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

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

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

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

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

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

impl<A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, G: Query, H: Query, I: Query, J: Query, K: Query, L: Query, M: Query, N: Query, O: Query, P: Query, Q: Query, R: Query> Query for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)

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

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

impl<A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, G: Query, H: Query, I: Query, J: Query, K: Query, L: Query, M: Query, N: Query, O: Query, P: Query, Q: Query, R: Query, S: Query, T: Query> Query for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

type Fetch = (<A as Query>::Fetch, <B as Query>::Fetch, <C as Query>::Fetch, <D as Query>::Fetch, <E as Query>::Fetch, <F as Query>::Fetch, <G as Query>::Fetch, <H as Query>::Fetch, <I as Query>::Fetch, <J as Query>::Fetch, <K as Query>::Fetch, <L as Query>::Fetch, <M as Query>::Fetch, <N as Query>::Fetch, <O as Query>::Fetch, <P as Query>::Fetch, <Q as Query>::Fetch, <R as Query>::Fetch, <S as Query>::Fetch, <T as Query>::Fetch)

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

impl<A: Query, B: Query> Query for (A, B)

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

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

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

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

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

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

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

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

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

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

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

impl<A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, G: Query, H: Query, I: Query, J: Query, K: Query, L: Query, M: Query, N: Query, O: Query, P: Query, Q: Query, R: Query, S: Query, T: Query, U: Query, V: Query, W: Query, X: Query, Y: Query> Query for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)

type Fetch = (<A as Query>::Fetch, <B as Query>::Fetch, <C as Query>::Fetch, <D as Query>::Fetch, <E as Query>::Fetch, <F as Query>::Fetch, <G as Query>::Fetch, <H as Query>::Fetch, <I as Query>::Fetch, <J as Query>::Fetch, <K as Query>::Fetch, <L as Query>::Fetch, <M as Query>::Fetch, <N as Query>::Fetch, <O as Query>::Fetch, <P as Query>::Fetch, <Q as Query>::Fetch, <R as Query>::Fetch, <S as Query>::Fetch, <T as Query>::Fetch, <U as Query>::Fetch, <V as Query>::Fetch, <W as Query>::Fetch, <X as Query>::Fetch, <Y as Query>::Fetch)

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

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

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

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

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

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

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

impl<A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, G: Query, H: Query, I: Query, J: Query, K: Query, L: Query, M: Query, N: Query, O: Query, P: Query, Q: Query, R: Query, S: Query, T: Query, U: Query, V: Query> Query for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)

type Fetch = (<A as Query>::Fetch, <B as Query>::Fetch, <C as Query>::Fetch, <D as Query>::Fetch, <E as Query>::Fetch, <F as Query>::Fetch, <G as Query>::Fetch, <H as Query>::Fetch, <I as Query>::Fetch, <J as Query>::Fetch, <K as Query>::Fetch, <L as Query>::Fetch, <M as Query>::Fetch, <N as Query>::Fetch, <O as Query>::Fetch, <P as Query>::Fetch, <Q as Query>::Fetch, <R as Query>::Fetch, <S as Query>::Fetch, <T as Query>::Fetch, <U as Query>::Fetch, <V as Query>::Fetch)

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

impl<A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, G: Query, H: Query, I: Query, J: Query, K: Query, L: Query, M: Query, N: Query, O: Query, P: Query, Q: Query, R: Query, S: Query, T: Query, U: Query, V: Query, W: Query, X: Query> Query for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)

type Fetch = (<A as Query>::Fetch, <B as Query>::Fetch, <C as Query>::Fetch, <D as Query>::Fetch, <E as Query>::Fetch, <F as Query>::Fetch, <G as Query>::Fetch, <H as Query>::Fetch, <I as Query>::Fetch, <J as Query>::Fetch, <K as Query>::Fetch, <L as Query>::Fetch, <M as Query>::Fetch, <N as Query>::Fetch, <O as Query>::Fetch, <P as Query>::Fetch, <Q as Query>::Fetch, <R as Query>::Fetch, <S as Query>::Fetch, <T as Query>::Fetch, <U as Query>::Fetch, <V as Query>::Fetch, <W as Query>::Fetch, <X as Query>::Fetch)

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

impl<A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, G: Query, H: Query, I: Query, J: Query, K: Query, L: Query, M: Query, N: Query, O: Query, P: Query, Q: Query, R: Query, S: Query, T: Query, U: Query> Query for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)

type Fetch = (<A as Query>::Fetch, <B as Query>::Fetch, <C as Query>::Fetch, <D as Query>::Fetch, <E as Query>::Fetch, <F as Query>::Fetch, <G as Query>::Fetch, <H as Query>::Fetch, <I as Query>::Fetch, <J as Query>::Fetch, <K as Query>::Fetch, <L as Query>::Fetch, <M as Query>::Fetch, <N as Query>::Fetch, <O as Query>::Fetch, <P as Query>::Fetch, <Q as Query>::Fetch, <R as Query>::Fetch, <S as Query>::Fetch, <T as Query>::Fetch, <U as Query>::Fetch)

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

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

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

fn filter(world: &World, entities: &mut Option<BTreeSet<Entity>>)

fn fetch(world: &World, entity: Entity) -> Self::Fetch

Implementors

impl Query for Element

type Fetch = Element

impl Query for Entity

type Fetch = Entity

impl<Component: 'static> Query for With<Component>

type Fetch = ()