Trait AsQuery 

pub trait AsQuery {
    type Query: Query;
}

Types associated with a query type.

Required Associated Types

type Query: Query

Associated query type.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl AsQuery for ()

type Query = ()

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

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

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

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

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

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

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

where C: AsQuery, D: AsQuery, E: AsQuery, F: AsQuery, G: AsQuery, H: AsQuery, I: AsQuery, J: AsQuery, K: AsQuery, L: AsQuery, M: AsQuery, N: AsQuery, O: AsQuery, P: AsQuery,

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

impl<D, E, F, G, H, I, J, K, L, M, N, O, P> AsQuery for (D, E, F, G, H, I, J, K, L, M, N, O, P)

where D: AsQuery, E: AsQuery, F: AsQuery, G: AsQuery, H: AsQuery, I: AsQuery, J: AsQuery, K: AsQuery, L: AsQuery, M: AsQuery, N: AsQuery, O: AsQuery, P: AsQuery,

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

impl<E, F, G, H, I, J, K, L, M, N, O, P> AsQuery for (E, F, G, H, I, J, K, L, M, N, O, P)

where E: AsQuery, F: AsQuery, G: AsQuery, H: AsQuery, I: AsQuery, J: AsQuery, K: AsQuery, L: AsQuery, M: AsQuery, N: AsQuery, O: AsQuery, P: AsQuery,

type Query = (<E as AsQuery>::Query, <F as AsQuery>::Query, <G as AsQuery>::Query, <H as AsQuery>::Query, <I as AsQuery>::Query, <J as AsQuery>::Query, <K as AsQuery>::Query, <L as AsQuery>::Query, <M as AsQuery>::Query, <N as AsQuery>::Query, <O as AsQuery>::Query, <P as AsQuery>::Query)

impl<F, G, H, I, J, K, L, M, N, O, P> AsQuery for (F, G, H, I, J, K, L, M, N, O, P)

where F: AsQuery, G: AsQuery, H: AsQuery, I: AsQuery, J: AsQuery, K: AsQuery, L: AsQuery, M: AsQuery, N: AsQuery, O: AsQuery, P: AsQuery,

type Query = (<F as AsQuery>::Query, <G as AsQuery>::Query, <H as AsQuery>::Query, <I as AsQuery>::Query, <J as AsQuery>::Query, <K as AsQuery>::Query, <L as AsQuery>::Query, <M as AsQuery>::Query, <N as AsQuery>::Query, <O as AsQuery>::Query, <P as AsQuery>::Query)

impl<G, H, I, J, K, L, M, N, O, P> AsQuery for (G, H, I, J, K, L, M, N, O, P)

where G: AsQuery, H: AsQuery, I: AsQuery, J: AsQuery, K: AsQuery, L: AsQuery, M: AsQuery, N: AsQuery, O: AsQuery, P: AsQuery,

type Query = (<G as AsQuery>::Query, <H as AsQuery>::Query, <I as AsQuery>::Query, <J as AsQuery>::Query, <K as AsQuery>::Query, <L as AsQuery>::Query, <M as AsQuery>::Query, <N as AsQuery>::Query, <O as AsQuery>::Query, <P as AsQuery>::Query)

impl<H, I, J, K, L, M, N, O, P> AsQuery for (H, I, J, K, L, M, N, O, P)

where H: AsQuery, I: AsQuery, J: AsQuery, K: AsQuery, L: AsQuery, M: AsQuery, N: AsQuery, O: AsQuery, P: AsQuery,

type Query = (<H as AsQuery>::Query, <I as AsQuery>::Query, <J as AsQuery>::Query, <K as AsQuery>::Query, <L as AsQuery>::Query, <M as AsQuery>::Query, <N as AsQuery>::Query, <O as AsQuery>::Query, <P as AsQuery>::Query)

impl<I, J, K, L, M, N, O, P> AsQuery for (I, J, K, L, M, N, O, P)

where I: AsQuery, J: AsQuery, K: AsQuery, L: AsQuery, M: AsQuery, N: AsQuery, O: AsQuery, P: AsQuery,

type Query = (<I as AsQuery>::Query, <J as AsQuery>::Query, <K as AsQuery>::Query, <L as AsQuery>::Query, <M as AsQuery>::Query, <N as AsQuery>::Query, <O as AsQuery>::Query, <P as AsQuery>::Query)

impl<J, K, L, M, N, O, P> AsQuery for (J, K, L, M, N, O, P)

where J: AsQuery, K: AsQuery, L: AsQuery, M: AsQuery, N: AsQuery, O: AsQuery, P: AsQuery,

type Query = (<J as AsQuery>::Query, <K as AsQuery>::Query, <L as AsQuery>::Query, <M as AsQuery>::Query, <N as AsQuery>::Query, <O as AsQuery>::Query, <P as AsQuery>::Query)

impl<K, L, M, N, O, P> AsQuery for (K, L, M, N, O, P)

where K: AsQuery, L: AsQuery, M: AsQuery, N: AsQuery, O: AsQuery, P: AsQuery,

type Query = (<K as AsQuery>::Query, <L as AsQuery>::Query, <M as AsQuery>::Query, <N as AsQuery>::Query, <O as AsQuery>::Query, <P as AsQuery>::Query)

impl<L, M, N, O, P> AsQuery for (L, M, N, O, P)

where L: AsQuery, M: AsQuery, N: AsQuery, O: AsQuery, P: AsQuery,

type Query = (<L as AsQuery>::Query, <M as AsQuery>::Query, <N as AsQuery>::Query, <O as AsQuery>::Query, <P as AsQuery>::Query)

impl<M, N, O, P> AsQuery for (M, N, O, P)

where M: AsQuery, N: AsQuery, O: AsQuery, P: AsQuery,

type Query = (<M as AsQuery>::Query, <N as AsQuery>::Query, <O as AsQuery>::Query, <P as AsQuery>::Query)

impl<N, O, P> AsQuery for (N, O, P)

where N: AsQuery, O: AsQuery, P: AsQuery,

type Query = (<N as AsQuery>::Query, <O as AsQuery>::Query, <P as AsQuery>::Query)

impl<O, P> AsQuery for (O, P)

where O: AsQuery, P: AsQuery,

type Query = (<O as AsQuery>::Query, <P as AsQuery>::Query)

impl<P> AsQuery for (P,)

where P: AsQuery,

type Query = (<P as AsQuery>::Query,)

impl<T> AsQuery for &T

where T: 'static,

type Query = Read<T>

impl<T> AsQuery for &mut T

where T: 'static,

type Query = Write<T>

impl<T> AsQuery for Option<T>

where T: AsQuery,

type Query = OptionQuery<<T as AsQuery>::Query>

Implementors

impl AsQuery for Entities

type Query = Entities

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

where A: AsQuery, B: AsQuery, C: AsQuery, D: AsQuery, E: AsQuery, F: AsQuery, G: AsQuery, H: AsQuery, I: AsQuery, J: AsQuery, K: AsQuery, L: AsQuery, M: AsQuery, N: AsQuery, O: AsQuery, P: AsQuery, Op: BooleanFetchOp,

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

impl<Op, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> AsQuery for BooleanQuery<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), Op>

where B: AsQuery, C: AsQuery, D: AsQuery, E: AsQuery, F: AsQuery, G: AsQuery, H: AsQuery, I: AsQuery, J: AsQuery, K: AsQuery, L: AsQuery, M: AsQuery, N: AsQuery, O: AsQuery, P: AsQuery, Op: BooleanFetchOp,

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

impl<Op, C, D, E, F, G, H, I, J, K, L, M, N, O, P> AsQuery for BooleanQuery<(C, D, E, F, G, H, I, J, K, L, M, N, O, P), Op>

where C: AsQuery, D: AsQuery, E: AsQuery, F: AsQuery, G: AsQuery, H: AsQuery, I: AsQuery, J: AsQuery, K: AsQuery, L: AsQuery, M: AsQuery, N: AsQuery, O: AsQuery, P: AsQuery, Op: BooleanFetchOp,

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

impl<Op, D, E, F, G, H, I, J, K, L, M, N, O, P> AsQuery for BooleanQuery<(D, E, F, G, H, I, J, K, L, M, N, O, P), Op>

where D: AsQuery, E: AsQuery, F: AsQuery, G: AsQuery, H: AsQuery, I: AsQuery, J: AsQuery, K: AsQuery, L: AsQuery, M: AsQuery, N: AsQuery, O: AsQuery, P: AsQuery, Op: BooleanFetchOp,

type Query = BooleanQuery<(<D as AsQuery>::Query, <E as AsQuery>::Query, <F as AsQuery>::Query, <G as AsQuery>::Query, <H as AsQuery>::Query, <I as AsQuery>::Query, <J as AsQuery>::Query, <K as AsQuery>::Query, <L as AsQuery>::Query, <M as AsQuery>::Query, <N as AsQuery>::Query, <O as AsQuery>::Query, <P as AsQuery>::Query), Op>

impl<Op, E, F, G, H, I, J, K, L, M, N, O, P> AsQuery for BooleanQuery<(E, F, G, H, I, J, K, L, M, N, O, P), Op>

where E: AsQuery, F: AsQuery, G: AsQuery, H: AsQuery, I: AsQuery, J: AsQuery, K: AsQuery, L: AsQuery, M: AsQuery, N: AsQuery, O: AsQuery, P: AsQuery, Op: BooleanFetchOp,

type Query = BooleanQuery<(<E as AsQuery>::Query, <F as AsQuery>::Query, <G as AsQuery>::Query, <H as AsQuery>::Query, <I as AsQuery>::Query, <J as AsQuery>::Query, <K as AsQuery>::Query, <L as AsQuery>::Query, <M as AsQuery>::Query, <N as AsQuery>::Query, <O as AsQuery>::Query, <P as AsQuery>::Query), Op>

impl<Op, F, G, H, I, J, K, L, M, N, O, P> AsQuery for BooleanQuery<(F, G, H, I, J, K, L, M, N, O, P), Op>

where F: AsQuery, G: AsQuery, H: AsQuery, I: AsQuery, J: AsQuery, K: AsQuery, L: AsQuery, M: AsQuery, N: AsQuery, O: AsQuery, P: AsQuery, Op: BooleanFetchOp,

type Query = BooleanQuery<(<F as AsQuery>::Query, <G as AsQuery>::Query, <H as AsQuery>::Query, <I as AsQuery>::Query, <J as AsQuery>::Query, <K as AsQuery>::Query, <L as AsQuery>::Query, <M as AsQuery>::Query, <N as AsQuery>::Query, <O as AsQuery>::Query, <P as AsQuery>::Query), Op>

impl<Op, G, H, I, J, K, L, M, N, O, P> AsQuery for BooleanQuery<(G, H, I, J, K, L, M, N, O, P), Op>

where G: AsQuery, H: AsQuery, I: AsQuery, J: AsQuery, K: AsQuery, L: AsQuery, M: AsQuery, N: AsQuery, O: AsQuery, P: AsQuery, Op: BooleanFetchOp,

type Query = BooleanQuery<(<G as AsQuery>::Query, <H as AsQuery>::Query, <I as AsQuery>::Query, <J as AsQuery>::Query, <K as AsQuery>::Query, <L as AsQuery>::Query, <M as AsQuery>::Query, <N as AsQuery>::Query, <O as AsQuery>::Query, <P as AsQuery>::Query), Op>

impl<Op, H, I, J, K, L, M, N, O, P> AsQuery for BooleanQuery<(H, I, J, K, L, M, N, O, P), Op>

where H: AsQuery, I: AsQuery, J: AsQuery, K: AsQuery, L: AsQuery, M: AsQuery, N: AsQuery, O: AsQuery, P: AsQuery, Op: BooleanFetchOp,

type Query = BooleanQuery<(<H as AsQuery>::Query, <I as AsQuery>::Query, <J as AsQuery>::Query, <K as AsQuery>::Query, <L as AsQuery>::Query, <M as AsQuery>::Query, <N as AsQuery>::Query, <O as AsQuery>::Query, <P as AsQuery>::Query), Op>

impl<Op, I, J, K, L, M, N, O, P> AsQuery for BooleanQuery<(I, J, K, L, M, N, O, P), Op>

where I: AsQuery, J: AsQuery, K: AsQuery, L: AsQuery, M: AsQuery, N: AsQuery, O: AsQuery, P: AsQuery, Op: BooleanFetchOp,

type Query = BooleanQuery<(<I as AsQuery>::Query, <J as AsQuery>::Query, <K as AsQuery>::Query, <L as AsQuery>::Query, <M as AsQuery>::Query, <N as AsQuery>::Query, <O as AsQuery>::Query, <P as AsQuery>::Query), Op>

impl<Op, J, K, L, M, N, O, P> AsQuery for BooleanQuery<(J, K, L, M, N, O, P), Op>

where J: AsQuery, K: AsQuery, L: AsQuery, M: AsQuery, N: AsQuery, O: AsQuery, P: AsQuery, Op: BooleanFetchOp,

type Query = BooleanQuery<(<J as AsQuery>::Query, <K as AsQuery>::Query, <L as AsQuery>::Query, <M as AsQuery>::Query, <N as AsQuery>::Query, <O as AsQuery>::Query, <P as AsQuery>::Query), Op>

impl<Op, K, L, M, N, O, P> AsQuery for BooleanQuery<(K, L, M, N, O, P), Op>

where K: AsQuery, L: AsQuery, M: AsQuery, N: AsQuery, O: AsQuery, P: AsQuery, Op: BooleanFetchOp,

type Query = BooleanQuery<(<K as AsQuery>::Query, <L as AsQuery>::Query, <M as AsQuery>::Query, <N as AsQuery>::Query, <O as AsQuery>::Query, <P as AsQuery>::Query), Op>

impl<Op, L, M, N, O, P> AsQuery for BooleanQuery<(L, M, N, O, P), Op>

where L: AsQuery, M: AsQuery, N: AsQuery, O: AsQuery, P: AsQuery, Op: BooleanFetchOp,

type Query = BooleanQuery<(<L as AsQuery>::Query, <M as AsQuery>::Query, <N as AsQuery>::Query, <O as AsQuery>::Query, <P as AsQuery>::Query), Op>

impl<Op, M, N, O, P> AsQuery for BooleanQuery<(M, N, O, P), Op>

where M: AsQuery, N: AsQuery, O: AsQuery, P: AsQuery, Op: BooleanFetchOp,

type Query = BooleanQuery<(<M as AsQuery>::Query, <N as AsQuery>::Query, <O as AsQuery>::Query, <P as AsQuery>::Query), Op>

impl<Op, N, O, P> AsQuery for BooleanQuery<(N, O, P), Op>

where N: AsQuery, O: AsQuery, P: AsQuery, Op: BooleanFetchOp,

type Query = BooleanQuery<(<N as AsQuery>::Query, <O as AsQuery>::Query, <P as AsQuery>::Query), Op>

impl<Op, O, P> AsQuery for BooleanQuery<(O, P), Op>

where O: AsQuery, P: AsQuery, Op: BooleanFetchOp,

type Query = BooleanQuery<(<O as AsQuery>::Query, <P as AsQuery>::Query), Op>

impl<Op, P> AsQuery for BooleanQuery<(P,), Op>

where P: AsQuery, Op: BooleanFetchOp,

type Query = BooleanQuery<(<P as AsQuery>::Query,), Op>

impl<R> AsQuery for FilterRelated<R>

where R: Relation,

type Query = FilterRelated<R>

impl<R> AsQuery for FilterRelatedBy<R>

where R: Relation,

type Query = FilterRelatedBy<R>

impl<R> AsQuery for FilterRelates<R>

where R: Relation,

type Query = FilterRelates<R>

impl<R> AsQuery for FilterRelatesTo<R>

where R: Relation,

type Query = FilterRelatesTo<R>

impl<R> AsQuery for Related<R>

where R: Relation,

type Query = Related<R>

impl<R> AsQuery for Relates<&R>

where R: Relation,

type Query = Relates<Read<R>>

impl<R> AsQuery for Relates<&mut R>

where R: Relation,

type Query = Relates<Write<R>>

impl<R> AsQuery for Relates<Read<R>>

where R: Relation,

type Query = Relates<Read<R>>

impl<R> AsQuery for Relates<Write<R>>

where R: Relation,

type Query = Relates<Write<R>>

impl<R> AsQuery for RelatesExclusive<&R>

where R: ExclusiveRelation,

type Query = RelatesExclusive<Read<R>>

impl<R> AsQuery for RelatesExclusive<&mut R>

where R: ExclusiveRelation,

type Query = RelatesExclusive<Write<R>>

impl<R> AsQuery for RelatesExclusive<Read<R>>

where R: ExclusiveRelation,

type Query = RelatesExclusive<Read<R>>

impl<R> AsQuery for RelatesExclusive<Write<R>>

where R: ExclusiveRelation,

type Query = RelatesExclusive<Write<R>>

impl<R> AsQuery for RelatesTo<&R>

where R: Relation + 'static,

type Query = RelatesTo<Read<R>>

impl<R> AsQuery for RelatesTo<&mut R>

where R: Relation,

type Query = RelatesTo<Write<R>>

impl<R> AsQuery for RelatesTo<Read<R>>

where R: Relation + 'static,

type Query = RelatesTo<Read<R>>

impl<R> AsQuery for RelatesTo<Write<R>>

where R: Relation,

type Query = RelatesTo<Write<R>>

impl<T> AsQuery for Alt<T>

where T: 'static,

type Query = Alt<T>

impl<T> AsQuery for Cpy<T>

where T: Copy + 'static,

type Query = Cpy<T>

impl<T> AsQuery for EpochOf<T>

where T: 'static,

type Query = EpochOf<T>

impl<T> AsQuery for Modified<&T>

where T: 'static,

type Query = Modified<Read<T>>

impl<T> AsQuery for Modified<&mut T>

where T: 'static,

type Query = Modified<Write<T>>

impl<T> AsQuery for Modified<Alt<T>>

where T: 'static,

type Query = Modified<Alt<T>>

impl<T> AsQuery for Modified<Cpy<T>>

where T: Copy + 'static,

type Query = Modified<Cpy<T>>

impl<T> AsQuery for Modified<Option<&T>>

where T: 'static,

type Query = Modified<OptionQuery<Read<T>>>

impl<T> AsQuery for Modified<Option<&mut T>>

where T: 'static,

type Query = Modified<OptionQuery<Write<T>>>

impl<T> AsQuery for Modified<Option<Alt<T>>>

where T: 'static,

type Query = Modified<OptionQuery<Alt<T>>>

impl<T> AsQuery for Modified<Option<Cpy<T>>>

where T: Copy + 'static,

type Query = Modified<OptionQuery<Cpy<T>>>

impl<T> AsQuery for Modified<OptionQuery<Alt<T>>>

where T: 'static,

type Query = Modified<OptionQuery<Alt<T>>>

impl<T> AsQuery for Modified<OptionQuery<Cpy<T>>>

where T: Copy + 'static,

type Query = Modified<OptionQuery<Cpy<T>>>

impl<T> AsQuery for Modified<OptionQuery<Read<T>>>

where T: 'static,

type Query = Modified<OptionQuery<Read<T>>>

impl<T> AsQuery for Modified<OptionQuery<Write<T>>>

where T: 'static,

type Query = Modified<OptionQuery<Write<T>>>

impl<T> AsQuery for Modified<Read<T>>

where T: 'static,

type Query = Modified<Read<T>>

impl<T> AsQuery for Modified<With<T>>

where T: 'static,

type Query = Modified<With<T>>

impl<T> AsQuery for Modified<Write<T>>

where T: 'static,

type Query = Modified<Write<T>>

impl<T> AsQuery for Not<T>

where T: AsQuery,

type Query = Not<<T as AsQuery>::Query>

impl<T> AsQuery for QueryBorrowAll<&T>

where T: ?Sized + 'static,

type Query = QueryBorrowAll<Read<T>>

impl<T> AsQuery for QueryBorrowAll<&mut T>

where T: ?Sized + 'static,

type Query = QueryBorrowAll<Write<T>>

impl<T> AsQuery for QueryBorrowAll<Read<T>>

where T: ?Sized + 'static,

type Query = QueryBorrowAll<Read<T>>

impl<T> AsQuery for QueryBorrowAll<Write<T>>

where T: ?Sized + 'static,

type Query = QueryBorrowAll<Write<T>>

impl<T> AsQuery for QueryBorrowAny<&T>

where T: ?Sized + 'static,

type Query = QueryBorrowAny<Read<T>>

impl<T> AsQuery for QueryBorrowAny<&mut T>

where T: ?Sized + 'static,

type Query = QueryBorrowAny<Write<T>>

impl<T> AsQuery for QueryBorrowAny<Read<T>>

where T: ?Sized + 'static,

type Query = QueryBorrowAny<Read<T>>

impl<T> AsQuery for QueryBorrowAny<Write<T>>

where T: ?Sized + 'static,

type Query = QueryBorrowAny<Write<T>>

impl<T> AsQuery for QueryBorrowOne<&T>

where T: ?Sized + 'static,

type Query = QueryBorrowOne<Read<T>>

impl<T> AsQuery for QueryBorrowOne<&mut T>

where T: ?Sized + 'static,

type Query = QueryBorrowOne<Write<T>>

impl<T> AsQuery for QueryBorrowOne<Read<T>>

where T: ?Sized + 'static,

type Query = QueryBorrowOne<Read<T>>

impl<T> AsQuery for QueryBorrowOne<Write<T>>

where T: ?Sized + 'static,

type Query = QueryBorrowOne<Write<T>>

impl<T> AsQuery for Read<T>

where T: 'static,

type Query = Read<T>

impl<T> AsQuery for With<T>

where T: 'static,

type Query = With<T>

impl<T> AsQuery for Write<T>

where T: 'static,

type Query = Write<T>