Trait AsQuery

pub trait AsQuery {
    type Query: Query;
}

Types associated with a query type.

Required Associated Types

type Query: Query

Associated query type.

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 Option<T>

where T: AsQuery,

type Query = OptionQuery<<T 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>

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 FilterRelates<R>

where R: Relation,

type Query = FilterRelates<R>

impl<R> AsQuery for Related<R>

where R: Relation,

type Query = Related<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 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 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 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 FilterRelatedBy<R>

where R: Relation,

type Query = FilterRelatedBy<R>

impl<R> AsQuery for FilterRelatesTo<R>

where R: Relation,

type Query = FilterRelatesTo<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<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<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 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>

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<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 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<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<&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<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 Not<T>

where T: AsQuery,

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

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 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 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 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 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 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>>