Trait IsQuery 

pub trait IsQuery {
    type LockedColumns<'a>;
    type ExtensionColumns: 'static;
    type QueryResult<'a>: Iterator<Item = Self::QueryRow<'a>>;
    type ParQueryResult<'a>: ParallelIterator<Item = Self::QueryRow<'a>> + IndexedParallelIterator;
    type QueryRow<'a>: Send + Sync;

    // Required methods
    fn reads() -> Vec<TypeKey>;
    fn writes() -> Vec<TypeKey>;
    fn lock_columns<'a>(arch: &'a Archetype) -> Self::LockedColumns<'a>;
    fn extend_locked_columns<'a, 'b>(
        lock: &'b mut Self::LockedColumns<'a>,
        extension_columns: Self::ExtensionColumns,
        output_ids: Option<(&mut Vec<usize>, &mut usize)>,
    );
    fn iter_mut<'a, 'b>(
        lock: &'b mut Self::LockedColumns<'a>,
    ) -> Self::QueryResult<'b>;
    fn iter_one<'a, 'b>(
        lock: &'b mut Self::LockedColumns<'a>,
        index: usize,
    ) -> Self::QueryResult<'b>;
    fn par_iter_mut<'a, 'b>(
        len: usize,
        lock: &'b mut Self::LockedColumns<'a>,
    ) -> Self::ParQueryResult<'b>;
}

Denotes the shape of a query that can be used to iterate over bundles of components.

Required Associated Types

type LockedColumns<'a>

Data that is read or write locked by performing this query.

type ExtensionColumns: 'static

Data that can be used to append to columns. Typically vectors of component entries or bundles of vectors of component entries.

type QueryResult<'a>: Iterator<Item = Self::QueryRow<'a>>

The iterator that is produced by performing a query on one archetype.

type ParQueryResult<'a>: ParallelIterator<Item = Self::QueryRow<'a>> + IndexedParallelIterator

The parallel iterator that is produced by performing a query on one archetype.

type QueryRow<'a>: Send + Sync

The iterator item.

Required Methods

fn reads() -> Vec<TypeKey>

fn writes() -> Vec<TypeKey>

fn lock_columns<'a>(arch: &'a Archetype) -> Self::LockedColumns<'a>

Find and acquire a “lock” on the columns for reading or writing.

fn extend_locked_columns<'a, 'b>( lock: &'b mut Self::LockedColumns<'a>, extension_columns: Self::ExtensionColumns, output_ids: Option<(&mut Vec<usize>, &mut usize)>, )

Extend entries in the locked columns.

This is for internal use only.

fn iter_mut<'a, 'b>( lock: &'b mut Self::LockedColumns<'a>, ) -> Self::QueryResult<'b>

Create an iterator over the rows of the given columns.

fn iter_one<'a, 'b>( lock: &'b mut Self::LockedColumns<'a>, index: usize, ) -> Self::QueryResult<'b>

Create an iterator over one row with the given index.

fn par_iter_mut<'a, 'b>( len: usize, lock: &'b mut Self::LockedColumns<'a>, ) -> Self::ParQueryResult<'b>

Create an iterator over the rows of the given columns.

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<'s, T: Send + Sync + 'static> IsQuery for &'s T

fn par_iter_mut<'a, 'b>( _: usize, lock: &'b mut Self::LockedColumns<'a>, ) -> Self::ParQueryResult<'b>

Create an iterator over the rows of the given columns.

type LockedColumns<'a> = Option<RwLockReadGuard<'a, RawRwLock, AnyVec<dyn Sync + Send>>>

type ExtensionColumns = ()

type QueryResult<'a> = Iter<'a, Entry<T>>

type ParQueryResult<'a> = Iter<'a, Entry<T>>

type QueryRow<'a> = &'a Entry<T>

fn reads() -> Vec<TypeKey>

fn writes() -> Vec<TypeKey>

fn lock_columns<'t>(arch: &'t Archetype) -> Self::LockedColumns<'t>

fn extend_locked_columns<'a, 'b>( _: &'b mut Self::LockedColumns<'a>, (): Self::ExtensionColumns, _: Option<(&mut Vec<usize>, &mut usize)>, )

fn iter_mut<'a, 'b>( locked: &'b mut Self::LockedColumns<'a>, ) -> Self::QueryResult<'b>

fn iter_one<'a, 'b>( lock: &'b mut Self::LockedColumns<'a>, index: usize, ) -> Self::QueryResult<'b>

impl<'s, T: Send + Sync + 'static> IsQuery for &'s mut T

fn par_iter_mut<'a, 'b>( _: usize, lock: &'b mut Self::LockedColumns<'a>, ) -> Self::ParQueryResult<'b>

Create an iterator over the rows of the given columns.

type LockedColumns<'a> = Option<RwLockWriteGuard<'a, RawRwLock, AnyVec<dyn Sync + Send>>>

type ExtensionColumns = Box<dyn Iterator<Item = Entry<T>>>

type QueryResult<'a> = IterMut<'a, Entry<T>>

type ParQueryResult<'a> = IterMut<'a, Entry<T>>

type QueryRow<'a> = &'a mut Entry<T>

fn reads() -> Vec<TypeKey>

fn writes() -> Vec<TypeKey>

fn lock_columns<'t>(arch: &'t Archetype) -> Self::LockedColumns<'t>

fn extend_locked_columns<'a, 'b>( lock: &'b mut Self::LockedColumns<'a>, extension_columns: Self::ExtensionColumns, output_ids: Option<(&mut Vec<usize>, &mut usize)>, )

fn iter_mut<'a, 'b>( locked: &'b mut Self::LockedColumns<'a>, ) -> Self::QueryResult<'b>

fn iter_one<'a, 'b>( lock: &'b mut Self::LockedColumns<'a>, index: usize, ) -> Self::QueryResult<'b>

impl<A> IsQuery for (A,)

where A: IsQuery,

type LockedColumns<'a> = <A as IsQuery>::LockedColumns<'a>

type ExtensionColumns = <A as IsQuery>::ExtensionColumns

type QueryResult<'a> = <A as IsQuery>::QueryResult<'a>

type ParQueryResult<'a> = <A as IsQuery>::ParQueryResult<'a>

type QueryRow<'a> = <A as IsQuery>::QueryRow<'a>

fn reads() -> Vec<TypeKey>

fn writes() -> Vec<TypeKey>

fn lock_columns<'t>(arch: &'t Archetype) -> Self::LockedColumns<'t>

fn extend_locked_columns<'a, 'b>( lock: &'b mut Self::LockedColumns<'a>, ext: Self::ExtensionColumns, output_ids: Option<(&mut Vec<usize>, &mut usize)>, )

fn iter_mut<'a, 'b>( lock: &'b mut Self::LockedColumns<'a>, ) -> Self::QueryResult<'b>

fn iter_one<'a, 'b>( lock: &'b mut Self::LockedColumns<'a>, index: usize, ) -> Self::QueryResult<'b>

fn par_iter_mut<'a, 'b>( len: usize, lock: &'b mut Self::LockedColumns<'a>, ) -> Self::ParQueryResult<'b>

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

where A: IsQuery, B: IsQuery,

type LockedColumns<'a> = (<A as IsQuery>::LockedColumns<'a>, <B as IsQuery>::LockedColumns<'a>)

type ExtensionColumns = (<A as IsQuery>::ExtensionColumns, <B as IsQuery>::ExtensionColumns)

type QueryResult<'a> = Zip<<A as IsQuery>::QueryResult<'a>, <B as IsQuery>::QueryResult<'a>>

type ParQueryResult<'a> = Zip<<A as IsQuery>::ParQueryResult<'a>, <B as IsQuery>::ParQueryResult<'a>>

type QueryRow<'a> = (<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>)

fn reads() -> Vec<TypeKey>

fn writes() -> Vec<TypeKey>

fn lock_columns<'t>(arch: &'t Archetype) -> Self::LockedColumns<'t>

fn extend_locked_columns<'a, 'b>( (a, b): &'b mut Self::LockedColumns<'a>, (ea, eb): Self::ExtensionColumns, output_ids: Option<(&mut Vec<usize>, &mut usize)>, )

fn iter_mut<'a, 'b>( (col_a, col_b): &'b mut Self::LockedColumns<'a>, ) -> Self::QueryResult<'b>

fn iter_one<'a, 'b>( (col_a, col_b): &'b mut Self::LockedColumns<'a>, index: usize, ) -> Self::QueryResult<'b>

fn par_iter_mut<'a, 'b>( len: usize, (col_a, col_b): &'b mut Self::LockedColumns<'a>, ) -> Self::ParQueryResult<'b>

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

where A: IsQuery, B: IsQuery, C: IsQuery,

type LockedColumns<'a> = (<A as IsQuery>::LockedColumns<'a>, <B as IsQuery>::LockedColumns<'a>, <C as IsQuery>::LockedColumns<'a>)

type ExtensionColumns = (<A as IsQuery>::ExtensionColumns, <B as IsQuery>::ExtensionColumns, <C as IsQuery>::ExtensionColumns)

type QueryResult<'a> = Map<Zip<Zip<<A as IsQuery>::QueryResult<'a>, <B as IsQuery>::QueryResult<'a>>, <C as IsQuery>::QueryResult<'a>>, fn(((<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>), <C as IsQuery>::QueryRow<'a>)) -> (<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>, <C as IsQuery>::QueryRow<'a>)>

type ParQueryResult<'a> = Map<Zip<Zip<<A as IsQuery>::ParQueryResult<'a>, <B as IsQuery>::ParQueryResult<'a>>, <C as IsQuery>::ParQueryResult<'a>>, fn(((<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>), <C as IsQuery>::QueryRow<'a>)) -> (<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>, <C as IsQuery>::QueryRow<'a>)>

type QueryRow<'a> = (<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>, <C as IsQuery>::QueryRow<'a>)

fn reads() -> Vec<TypeKey>

fn writes() -> Vec<TypeKey>

fn lock_columns<'t>(arch: &'t Archetype) -> Self::LockedColumns<'t>

fn extend_locked_columns<'a, 'b>( (n0, n1, n2): &'b mut Self::LockedColumns<'a>, (m0, m1, m2): Self::ExtensionColumns, output_ids: Option<(&mut Vec<usize>, &mut usize)>, )

fn iter_mut<'a, 'b>( (n0, n1, n2): &'b mut Self::LockedColumns<'a>, ) -> Self::QueryResult<'b>

fn iter_one<'a, 'b>( (n0, n1, n2): &'b mut Self::LockedColumns<'a>, index: usize, ) -> Self::QueryResult<'b>

fn par_iter_mut<'a, 'b>( len: usize, (n0, n1, n2): &'b mut Self::LockedColumns<'a>, ) -> Self::ParQueryResult<'b>

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

where A: IsQuery, B: IsQuery, C: IsQuery, D: IsQuery,

type LockedColumns<'a> = (<A as IsQuery>::LockedColumns<'a>, <B as IsQuery>::LockedColumns<'a>, <C as IsQuery>::LockedColumns<'a>, <D as IsQuery>::LockedColumns<'a>)

type ExtensionColumns = (<A as IsQuery>::ExtensionColumns, <B as IsQuery>::ExtensionColumns, <C as IsQuery>::ExtensionColumns, <D as IsQuery>::ExtensionColumns)

type QueryResult<'a> = Map<Zip<Zip<Zip<<A as IsQuery>::QueryResult<'a>, <B as IsQuery>::QueryResult<'a>>, <C as IsQuery>::QueryResult<'a>>, <D as IsQuery>::QueryResult<'a>>, fn((((<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>), <C as IsQuery>::QueryRow<'a>), <D as IsQuery>::QueryRow<'a>)) -> (<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>, <C as IsQuery>::QueryRow<'a>, <D as IsQuery>::QueryRow<'a>)>

type ParQueryResult<'a> = Map<Zip<Zip<Zip<<A as IsQuery>::ParQueryResult<'a>, <B as IsQuery>::ParQueryResult<'a>>, <C as IsQuery>::ParQueryResult<'a>>, <D as IsQuery>::ParQueryResult<'a>>, fn((((<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>), <C as IsQuery>::QueryRow<'a>), <D as IsQuery>::QueryRow<'a>)) -> (<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>, <C as IsQuery>::QueryRow<'a>, <D as IsQuery>::QueryRow<'a>)>

type QueryRow<'a> = (<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>, <C as IsQuery>::QueryRow<'a>, <D as IsQuery>::QueryRow<'a>)

fn reads() -> Vec<TypeKey>

fn writes() -> Vec<TypeKey>

fn lock_columns<'t>(arch: &'t Archetype) -> Self::LockedColumns<'t>

fn extend_locked_columns<'a, 'b>( (n0, n1, n2, n3): &'b mut Self::LockedColumns<'a>, (m0, m1, m2, m3): Self::ExtensionColumns, output_ids: Option<(&mut Vec<usize>, &mut usize)>, )

fn iter_mut<'a, 'b>( (n0, n1, n2, n3): &'b mut Self::LockedColumns<'a>, ) -> Self::QueryResult<'b>

fn iter_one<'a, 'b>( (n0, n1, n2, n3): &'b mut Self::LockedColumns<'a>, index: usize, ) -> Self::QueryResult<'b>

fn par_iter_mut<'a, 'b>( len: usize, (n0, n1, n2, n3): &'b mut Self::LockedColumns<'a>, ) -> Self::ParQueryResult<'b>

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

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

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

type ExtensionColumns = (<A as IsQuery>::ExtensionColumns, <B as IsQuery>::ExtensionColumns, <C as IsQuery>::ExtensionColumns, <D as IsQuery>::ExtensionColumns, <E as IsQuery>::ExtensionColumns)

type QueryResult<'a> = Map<Zip<Zip<Zip<Zip<<A as IsQuery>::QueryResult<'a>, <B as IsQuery>::QueryResult<'a>>, <C as IsQuery>::QueryResult<'a>>, <D as IsQuery>::QueryResult<'a>>, <E as IsQuery>::QueryResult<'a>>, fn(((((<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>), <C as IsQuery>::QueryRow<'a>), <D as IsQuery>::QueryRow<'a>), <E as IsQuery>::QueryRow<'a>)) -> (<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>, <C as IsQuery>::QueryRow<'a>, <D as IsQuery>::QueryRow<'a>, <E as IsQuery>::QueryRow<'a>)>

type ParQueryResult<'a> = Map<Zip<Zip<Zip<Zip<<A as IsQuery>::ParQueryResult<'a>, <B as IsQuery>::ParQueryResult<'a>>, <C as IsQuery>::ParQueryResult<'a>>, <D as IsQuery>::ParQueryResult<'a>>, <E as IsQuery>::ParQueryResult<'a>>, fn(((((<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>), <C as IsQuery>::QueryRow<'a>), <D as IsQuery>::QueryRow<'a>), <E as IsQuery>::QueryRow<'a>)) -> (<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>, <C as IsQuery>::QueryRow<'a>, <D as IsQuery>::QueryRow<'a>, <E as IsQuery>::QueryRow<'a>)>

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

fn reads() -> Vec<TypeKey>

fn writes() -> Vec<TypeKey>

fn lock_columns<'t>(arch: &'t Archetype) -> Self::LockedColumns<'t>

fn extend_locked_columns<'a, 'b>( (n0, n1, n2, n3, n4): &'b mut Self::LockedColumns<'a>, (m0, m1, m2, m3, m4): Self::ExtensionColumns, output_ids: Option<(&mut Vec<usize>, &mut usize)>, )

fn iter_mut<'a, 'b>( (n0, n1, n2, n3, n4): &'b mut Self::LockedColumns<'a>, ) -> Self::QueryResult<'b>

fn iter_one<'a, 'b>( (n0, n1, n2, n3, n4): &'b mut Self::LockedColumns<'a>, index: usize, ) -> Self::QueryResult<'b>

fn par_iter_mut<'a, 'b>( len: usize, (n0, n1, n2, n3, n4): &'b mut Self::LockedColumns<'a>, ) -> Self::ParQueryResult<'b>

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

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

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

type ExtensionColumns = (<A as IsQuery>::ExtensionColumns, <B as IsQuery>::ExtensionColumns, <C as IsQuery>::ExtensionColumns, <D as IsQuery>::ExtensionColumns, <E as IsQuery>::ExtensionColumns, <F as IsQuery>::ExtensionColumns)

type QueryResult<'a> = Map<Zip<Zip<Zip<Zip<Zip<<A as IsQuery>::QueryResult<'a>, <B as IsQuery>::QueryResult<'a>>, <C as IsQuery>::QueryResult<'a>>, <D as IsQuery>::QueryResult<'a>>, <E as IsQuery>::QueryResult<'a>>, <F as IsQuery>::QueryResult<'a>>, fn((((((<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>), <C as IsQuery>::QueryRow<'a>), <D as IsQuery>::QueryRow<'a>), <E as IsQuery>::QueryRow<'a>), <F as IsQuery>::QueryRow<'a>)) -> (<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>, <C as IsQuery>::QueryRow<'a>, <D as IsQuery>::QueryRow<'a>, <E as IsQuery>::QueryRow<'a>, <F as IsQuery>::QueryRow<'a>)>

type ParQueryResult<'a> = Map<Zip<Zip<Zip<Zip<Zip<<A as IsQuery>::ParQueryResult<'a>, <B as IsQuery>::ParQueryResult<'a>>, <C as IsQuery>::ParQueryResult<'a>>, <D as IsQuery>::ParQueryResult<'a>>, <E as IsQuery>::ParQueryResult<'a>>, <F as IsQuery>::ParQueryResult<'a>>, fn((((((<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>), <C as IsQuery>::QueryRow<'a>), <D as IsQuery>::QueryRow<'a>), <E as IsQuery>::QueryRow<'a>), <F as IsQuery>::QueryRow<'a>)) -> (<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>, <C as IsQuery>::QueryRow<'a>, <D as IsQuery>::QueryRow<'a>, <E as IsQuery>::QueryRow<'a>, <F as IsQuery>::QueryRow<'a>)>

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

fn reads() -> Vec<TypeKey>

fn writes() -> Vec<TypeKey>

fn lock_columns<'t>(arch: &'t Archetype) -> Self::LockedColumns<'t>

fn extend_locked_columns<'a, 'b>( (n0, n1, n2, n3, n4, n5): &'b mut Self::LockedColumns<'a>, (m0, m1, m2, m3, m4, m5): Self::ExtensionColumns, output_ids: Option<(&mut Vec<usize>, &mut usize)>, )

fn iter_mut<'a, 'b>( (n0, n1, n2, n3, n4, n5): &'b mut Self::LockedColumns<'a>, ) -> Self::QueryResult<'b>

fn iter_one<'a, 'b>( (n0, n1, n2, n3, n4, n5): &'b mut Self::LockedColumns<'a>, index: usize, ) -> Self::QueryResult<'b>

fn par_iter_mut<'a, 'b>( len: usize, (n0, n1, n2, n3, n4, n5): &'b mut Self::LockedColumns<'a>, ) -> Self::ParQueryResult<'b>

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

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

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

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

type QueryResult<'a> = Map<Zip<Zip<Zip<Zip<Zip<Zip<<A as IsQuery>::QueryResult<'a>, <B as IsQuery>::QueryResult<'a>>, <C as IsQuery>::QueryResult<'a>>, <D as IsQuery>::QueryResult<'a>>, <E as IsQuery>::QueryResult<'a>>, <F as IsQuery>::QueryResult<'a>>, <G as IsQuery>::QueryResult<'a>>, fn(((((((<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>), <C as IsQuery>::QueryRow<'a>), <D as IsQuery>::QueryRow<'a>), <E as IsQuery>::QueryRow<'a>), <F as IsQuery>::QueryRow<'a>), <G as IsQuery>::QueryRow<'a>)) -> (<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>, <C as IsQuery>::QueryRow<'a>, <D as IsQuery>::QueryRow<'a>, <E as IsQuery>::QueryRow<'a>, <F as IsQuery>::QueryRow<'a>, <G as IsQuery>::QueryRow<'a>)>

type ParQueryResult<'a> = Map<Zip<Zip<Zip<Zip<Zip<Zip<<A as IsQuery>::ParQueryResult<'a>, <B as IsQuery>::ParQueryResult<'a>>, <C as IsQuery>::ParQueryResult<'a>>, <D as IsQuery>::ParQueryResult<'a>>, <E as IsQuery>::ParQueryResult<'a>>, <F as IsQuery>::ParQueryResult<'a>>, <G as IsQuery>::ParQueryResult<'a>>, fn(((((((<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>), <C as IsQuery>::QueryRow<'a>), <D as IsQuery>::QueryRow<'a>), <E as IsQuery>::QueryRow<'a>), <F as IsQuery>::QueryRow<'a>), <G as IsQuery>::QueryRow<'a>)) -> (<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>, <C as IsQuery>::QueryRow<'a>, <D as IsQuery>::QueryRow<'a>, <E as IsQuery>::QueryRow<'a>, <F as IsQuery>::QueryRow<'a>, <G as IsQuery>::QueryRow<'a>)>

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

fn reads() -> Vec<TypeKey>

fn writes() -> Vec<TypeKey>

fn lock_columns<'t>(arch: &'t Archetype) -> Self::LockedColumns<'t>

fn extend_locked_columns<'a, 'b>( (n0, n1, n2, n3, n4, n5, n6): &'b mut Self::LockedColumns<'a>, (m0, m1, m2, m3, m4, m5, m6): Self::ExtensionColumns, output_ids: Option<(&mut Vec<usize>, &mut usize)>, )

fn iter_mut<'a, 'b>( (n0, n1, n2, n3, n4, n5, n6): &'b mut Self::LockedColumns<'a>, ) -> Self::QueryResult<'b>

fn iter_one<'a, 'b>( (n0, n1, n2, n3, n4, n5, n6): &'b mut Self::LockedColumns<'a>, index: usize, ) -> Self::QueryResult<'b>

fn par_iter_mut<'a, 'b>( len: usize, (n0, n1, n2, n3, n4, n5, n6): &'b mut Self::LockedColumns<'a>, ) -> Self::ParQueryResult<'b>

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

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

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

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

type QueryResult<'a> = Map<Zip<Zip<Zip<Zip<Zip<Zip<Zip<<A as IsQuery>::QueryResult<'a>, <B as IsQuery>::QueryResult<'a>>, <C as IsQuery>::QueryResult<'a>>, <D as IsQuery>::QueryResult<'a>>, <E as IsQuery>::QueryResult<'a>>, <F as IsQuery>::QueryResult<'a>>, <G as IsQuery>::QueryResult<'a>>, <H as IsQuery>::QueryResult<'a>>, fn((((((((<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>), <C as IsQuery>::QueryRow<'a>), <D as IsQuery>::QueryRow<'a>), <E as IsQuery>::QueryRow<'a>), <F as IsQuery>::QueryRow<'a>), <G as IsQuery>::QueryRow<'a>), <H as IsQuery>::QueryRow<'a>)) -> (<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>, <C as IsQuery>::QueryRow<'a>, <D as IsQuery>::QueryRow<'a>, <E as IsQuery>::QueryRow<'a>, <F as IsQuery>::QueryRow<'a>, <G as IsQuery>::QueryRow<'a>, <H as IsQuery>::QueryRow<'a>)>

type ParQueryResult<'a> = Map<Zip<Zip<Zip<Zip<Zip<Zip<Zip<<A as IsQuery>::ParQueryResult<'a>, <B as IsQuery>::ParQueryResult<'a>>, <C as IsQuery>::ParQueryResult<'a>>, <D as IsQuery>::ParQueryResult<'a>>, <E as IsQuery>::ParQueryResult<'a>>, <F as IsQuery>::ParQueryResult<'a>>, <G as IsQuery>::ParQueryResult<'a>>, <H as IsQuery>::ParQueryResult<'a>>, fn((((((((<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>), <C as IsQuery>::QueryRow<'a>), <D as IsQuery>::QueryRow<'a>), <E as IsQuery>::QueryRow<'a>), <F as IsQuery>::QueryRow<'a>), <G as IsQuery>::QueryRow<'a>), <H as IsQuery>::QueryRow<'a>)) -> (<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>, <C as IsQuery>::QueryRow<'a>, <D as IsQuery>::QueryRow<'a>, <E as IsQuery>::QueryRow<'a>, <F as IsQuery>::QueryRow<'a>, <G as IsQuery>::QueryRow<'a>, <H as IsQuery>::QueryRow<'a>)>

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

fn reads() -> Vec<TypeKey>

fn writes() -> Vec<TypeKey>

fn lock_columns<'t>(arch: &'t Archetype) -> Self::LockedColumns<'t>

fn extend_locked_columns<'a, 'b>( (n0, n1, n2, n3, n4, n5, n6, n7): &'b mut Self::LockedColumns<'a>, (m0, m1, m2, m3, m4, m5, m6, m7): Self::ExtensionColumns, output_ids: Option<(&mut Vec<usize>, &mut usize)>, )

fn iter_mut<'a, 'b>( (n0, n1, n2, n3, n4, n5, n6, n7): &'b mut Self::LockedColumns<'a>, ) -> Self::QueryResult<'b>

fn iter_one<'a, 'b>( (n0, n1, n2, n3, n4, n5, n6, n7): &'b mut Self::LockedColumns<'a>, index: usize, ) -> Self::QueryResult<'b>

fn par_iter_mut<'a, 'b>( len: usize, (n0, n1, n2, n3, n4, n5, n6, n7): &'b mut Self::LockedColumns<'a>, ) -> Self::ParQueryResult<'b>

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

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

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

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

type QueryResult<'a> = Map<Zip<Zip<Zip<Zip<Zip<Zip<Zip<Zip<<A as IsQuery>::QueryResult<'a>, <B as IsQuery>::QueryResult<'a>>, <C as IsQuery>::QueryResult<'a>>, <D as IsQuery>::QueryResult<'a>>, <E as IsQuery>::QueryResult<'a>>, <F as IsQuery>::QueryResult<'a>>, <G as IsQuery>::QueryResult<'a>>, <H as IsQuery>::QueryResult<'a>>, <I as IsQuery>::QueryResult<'a>>, fn(((((((((<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>), <C as IsQuery>::QueryRow<'a>), <D as IsQuery>::QueryRow<'a>), <E as IsQuery>::QueryRow<'a>), <F as IsQuery>::QueryRow<'a>), <G as IsQuery>::QueryRow<'a>), <H as IsQuery>::QueryRow<'a>), <I as IsQuery>::QueryRow<'a>)) -> (<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>, <C as IsQuery>::QueryRow<'a>, <D as IsQuery>::QueryRow<'a>, <E as IsQuery>::QueryRow<'a>, <F as IsQuery>::QueryRow<'a>, <G as IsQuery>::QueryRow<'a>, <H as IsQuery>::QueryRow<'a>, <I as IsQuery>::QueryRow<'a>)>

type ParQueryResult<'a> = Map<Zip<Zip<Zip<Zip<Zip<Zip<Zip<Zip<<A as IsQuery>::ParQueryResult<'a>, <B as IsQuery>::ParQueryResult<'a>>, <C as IsQuery>::ParQueryResult<'a>>, <D as IsQuery>::ParQueryResult<'a>>, <E as IsQuery>::ParQueryResult<'a>>, <F as IsQuery>::ParQueryResult<'a>>, <G as IsQuery>::ParQueryResult<'a>>, <H as IsQuery>::ParQueryResult<'a>>, <I as IsQuery>::ParQueryResult<'a>>, fn(((((((((<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>), <C as IsQuery>::QueryRow<'a>), <D as IsQuery>::QueryRow<'a>), <E as IsQuery>::QueryRow<'a>), <F as IsQuery>::QueryRow<'a>), <G as IsQuery>::QueryRow<'a>), <H as IsQuery>::QueryRow<'a>), <I as IsQuery>::QueryRow<'a>)) -> (<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>, <C as IsQuery>::QueryRow<'a>, <D as IsQuery>::QueryRow<'a>, <E as IsQuery>::QueryRow<'a>, <F as IsQuery>::QueryRow<'a>, <G as IsQuery>::QueryRow<'a>, <H as IsQuery>::QueryRow<'a>, <I as IsQuery>::QueryRow<'a>)>

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

fn reads() -> Vec<TypeKey>

fn writes() -> Vec<TypeKey>

fn lock_columns<'t>(arch: &'t Archetype) -> Self::LockedColumns<'t>

fn extend_locked_columns<'a, 'b>( (n0, n1, n2, n3, n4, n5, n6, n7, n8): &'b mut Self::LockedColumns<'a>, (m0, m1, m2, m3, m4, m5, m6, m7, m8): Self::ExtensionColumns, output_ids: Option<(&mut Vec<usize>, &mut usize)>, )

fn iter_mut<'a, 'b>( (n0, n1, n2, n3, n4, n5, n6, n7, n8): &'b mut Self::LockedColumns<'a>, ) -> Self::QueryResult<'b>

fn iter_one<'a, 'b>( (n0, n1, n2, n3, n4, n5, n6, n7, n8): &'b mut Self::LockedColumns<'a>, index: usize, ) -> Self::QueryResult<'b>

fn par_iter_mut<'a, 'b>( len: usize, (n0, n1, n2, n3, n4, n5, n6, n7, n8): &'b mut Self::LockedColumns<'a>, ) -> Self::ParQueryResult<'b>

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

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

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

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

type QueryResult<'a> = Map<Zip<Zip<Zip<Zip<Zip<Zip<Zip<Zip<Zip<<A as IsQuery>::QueryResult<'a>, <B as IsQuery>::QueryResult<'a>>, <C as IsQuery>::QueryResult<'a>>, <D as IsQuery>::QueryResult<'a>>, <E as IsQuery>::QueryResult<'a>>, <F as IsQuery>::QueryResult<'a>>, <G as IsQuery>::QueryResult<'a>>, <H as IsQuery>::QueryResult<'a>>, <I as IsQuery>::QueryResult<'a>>, <J as IsQuery>::QueryResult<'a>>, fn((((((((((<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>), <C as IsQuery>::QueryRow<'a>), <D as IsQuery>::QueryRow<'a>), <E as IsQuery>::QueryRow<'a>), <F as IsQuery>::QueryRow<'a>), <G as IsQuery>::QueryRow<'a>), <H as IsQuery>::QueryRow<'a>), <I as IsQuery>::QueryRow<'a>), <J as IsQuery>::QueryRow<'a>)) -> (<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>, <C as IsQuery>::QueryRow<'a>, <D as IsQuery>::QueryRow<'a>, <E as IsQuery>::QueryRow<'a>, <F as IsQuery>::QueryRow<'a>, <G as IsQuery>::QueryRow<'a>, <H as IsQuery>::QueryRow<'a>, <I as IsQuery>::QueryRow<'a>, <J as IsQuery>::QueryRow<'a>)>

type ParQueryResult<'a> = Map<Zip<Zip<Zip<Zip<Zip<Zip<Zip<Zip<Zip<<A as IsQuery>::ParQueryResult<'a>, <B as IsQuery>::ParQueryResult<'a>>, <C as IsQuery>::ParQueryResult<'a>>, <D as IsQuery>::ParQueryResult<'a>>, <E as IsQuery>::ParQueryResult<'a>>, <F as IsQuery>::ParQueryResult<'a>>, <G as IsQuery>::ParQueryResult<'a>>, <H as IsQuery>::ParQueryResult<'a>>, <I as IsQuery>::ParQueryResult<'a>>, <J as IsQuery>::ParQueryResult<'a>>, fn((((((((((<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>), <C as IsQuery>::QueryRow<'a>), <D as IsQuery>::QueryRow<'a>), <E as IsQuery>::QueryRow<'a>), <F as IsQuery>::QueryRow<'a>), <G as IsQuery>::QueryRow<'a>), <H as IsQuery>::QueryRow<'a>), <I as IsQuery>::QueryRow<'a>), <J as IsQuery>::QueryRow<'a>)) -> (<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>, <C as IsQuery>::QueryRow<'a>, <D as IsQuery>::QueryRow<'a>, <E as IsQuery>::QueryRow<'a>, <F as IsQuery>::QueryRow<'a>, <G as IsQuery>::QueryRow<'a>, <H as IsQuery>::QueryRow<'a>, <I as IsQuery>::QueryRow<'a>, <J as IsQuery>::QueryRow<'a>)>

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

fn reads() -> Vec<TypeKey>

fn writes() -> Vec<TypeKey>

fn lock_columns<'t>(arch: &'t Archetype) -> Self::LockedColumns<'t>

fn extend_locked_columns<'a, 'b>( (n0, n1, n2, n3, n4, n5, n6, n7, n8, n9): &'b mut Self::LockedColumns<'a>, (m0, m1, m2, m3, m4, m5, m6, m7, m8, m9): Self::ExtensionColumns, output_ids: Option<(&mut Vec<usize>, &mut usize)>, )

fn iter_mut<'a, 'b>( (n0, n1, n2, n3, n4, n5, n6, n7, n8, n9): &'b mut Self::LockedColumns<'a>, ) -> Self::QueryResult<'b>

fn iter_one<'a, 'b>( (n0, n1, n2, n3, n4, n5, n6, n7, n8, n9): &'b mut Self::LockedColumns<'a>, index: usize, ) -> Self::QueryResult<'b>

fn par_iter_mut<'a, 'b>( len: usize, (n0, n1, n2, n3, n4, n5, n6, n7, n8, n9): &'b mut Self::LockedColumns<'a>, ) -> Self::ParQueryResult<'b>

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

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

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

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

type QueryResult<'a> = Map<Zip<Zip<Zip<Zip<Zip<Zip<Zip<Zip<Zip<Zip<<A as IsQuery>::QueryResult<'a>, <B as IsQuery>::QueryResult<'a>>, <C as IsQuery>::QueryResult<'a>>, <D as IsQuery>::QueryResult<'a>>, <E as IsQuery>::QueryResult<'a>>, <F as IsQuery>::QueryResult<'a>>, <G as IsQuery>::QueryResult<'a>>, <H as IsQuery>::QueryResult<'a>>, <I as IsQuery>::QueryResult<'a>>, <J as IsQuery>::QueryResult<'a>>, <K as IsQuery>::QueryResult<'a>>, fn(((((((((((<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>), <C as IsQuery>::QueryRow<'a>), <D as IsQuery>::QueryRow<'a>), <E as IsQuery>::QueryRow<'a>), <F as IsQuery>::QueryRow<'a>), <G as IsQuery>::QueryRow<'a>), <H as IsQuery>::QueryRow<'a>), <I as IsQuery>::QueryRow<'a>), <J as IsQuery>::QueryRow<'a>), <K as IsQuery>::QueryRow<'a>)) -> (<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>, <C as IsQuery>::QueryRow<'a>, <D as IsQuery>::QueryRow<'a>, <E as IsQuery>::QueryRow<'a>, <F as IsQuery>::QueryRow<'a>, <G as IsQuery>::QueryRow<'a>, <H as IsQuery>::QueryRow<'a>, <I as IsQuery>::QueryRow<'a>, <J as IsQuery>::QueryRow<'a>, <K as IsQuery>::QueryRow<'a>)>

type ParQueryResult<'a> = Map<Zip<Zip<Zip<Zip<Zip<Zip<Zip<Zip<Zip<Zip<<A as IsQuery>::ParQueryResult<'a>, <B as IsQuery>::ParQueryResult<'a>>, <C as IsQuery>::ParQueryResult<'a>>, <D as IsQuery>::ParQueryResult<'a>>, <E as IsQuery>::ParQueryResult<'a>>, <F as IsQuery>::ParQueryResult<'a>>, <G as IsQuery>::ParQueryResult<'a>>, <H as IsQuery>::ParQueryResult<'a>>, <I as IsQuery>::ParQueryResult<'a>>, <J as IsQuery>::ParQueryResult<'a>>, <K as IsQuery>::ParQueryResult<'a>>, fn(((((((((((<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>), <C as IsQuery>::QueryRow<'a>), <D as IsQuery>::QueryRow<'a>), <E as IsQuery>::QueryRow<'a>), <F as IsQuery>::QueryRow<'a>), <G as IsQuery>::QueryRow<'a>), <H as IsQuery>::QueryRow<'a>), <I as IsQuery>::QueryRow<'a>), <J as IsQuery>::QueryRow<'a>), <K as IsQuery>::QueryRow<'a>)) -> (<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>, <C as IsQuery>::QueryRow<'a>, <D as IsQuery>::QueryRow<'a>, <E as IsQuery>::QueryRow<'a>, <F as IsQuery>::QueryRow<'a>, <G as IsQuery>::QueryRow<'a>, <H as IsQuery>::QueryRow<'a>, <I as IsQuery>::QueryRow<'a>, <J as IsQuery>::QueryRow<'a>, <K as IsQuery>::QueryRow<'a>)>

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

fn reads() -> Vec<TypeKey>

fn writes() -> Vec<TypeKey>

fn lock_columns<'t>(arch: &'t Archetype) -> Self::LockedColumns<'t>

fn extend_locked_columns<'a, 'b>( (n0, n1, n2, n3, n4, n5, n6, n7, n8, n9, n10): &'b mut Self::LockedColumns<'a>, (m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10): Self::ExtensionColumns, output_ids: Option<(&mut Vec<usize>, &mut usize)>, )

fn iter_mut<'a, 'b>( (n0, n1, n2, n3, n4, n5, n6, n7, n8, n9, n10): &'b mut Self::LockedColumns<'a>, ) -> Self::QueryResult<'b>

fn iter_one<'a, 'b>( (n0, n1, n2, n3, n4, n5, n6, n7, n8, n9, n10): &'b mut Self::LockedColumns<'a>, index: usize, ) -> Self::QueryResult<'b>

fn par_iter_mut<'a, 'b>( len: usize, (n0, n1, n2, n3, n4, n5, n6, n7, n8, n9, n10): &'b mut Self::LockedColumns<'a>, ) -> Self::ParQueryResult<'b>

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

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

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

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

type QueryResult<'a> = Map<Zip<Zip<Zip<Zip<Zip<Zip<Zip<Zip<Zip<Zip<Zip<<A as IsQuery>::QueryResult<'a>, <B as IsQuery>::QueryResult<'a>>, <C as IsQuery>::QueryResult<'a>>, <D as IsQuery>::QueryResult<'a>>, <E as IsQuery>::QueryResult<'a>>, <F as IsQuery>::QueryResult<'a>>, <G as IsQuery>::QueryResult<'a>>, <H as IsQuery>::QueryResult<'a>>, <I as IsQuery>::QueryResult<'a>>, <J as IsQuery>::QueryResult<'a>>, <K as IsQuery>::QueryResult<'a>>, <L as IsQuery>::QueryResult<'a>>, fn((((((((((((<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>), <C as IsQuery>::QueryRow<'a>), <D as IsQuery>::QueryRow<'a>), <E as IsQuery>::QueryRow<'a>), <F as IsQuery>::QueryRow<'a>), <G as IsQuery>::QueryRow<'a>), <H as IsQuery>::QueryRow<'a>), <I as IsQuery>::QueryRow<'a>), <J as IsQuery>::QueryRow<'a>), <K as IsQuery>::QueryRow<'a>), <L as IsQuery>::QueryRow<'a>)) -> (<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>, <C as IsQuery>::QueryRow<'a>, <D as IsQuery>::QueryRow<'a>, <E as IsQuery>::QueryRow<'a>, <F as IsQuery>::QueryRow<'a>, <G as IsQuery>::QueryRow<'a>, <H as IsQuery>::QueryRow<'a>, <I as IsQuery>::QueryRow<'a>, <J as IsQuery>::QueryRow<'a>, <K as IsQuery>::QueryRow<'a>, <L as IsQuery>::QueryRow<'a>)>

type ParQueryResult<'a> = Map<Zip<Zip<Zip<Zip<Zip<Zip<Zip<Zip<Zip<Zip<Zip<<A as IsQuery>::ParQueryResult<'a>, <B as IsQuery>::ParQueryResult<'a>>, <C as IsQuery>::ParQueryResult<'a>>, <D as IsQuery>::ParQueryResult<'a>>, <E as IsQuery>::ParQueryResult<'a>>, <F as IsQuery>::ParQueryResult<'a>>, <G as IsQuery>::ParQueryResult<'a>>, <H as IsQuery>::ParQueryResult<'a>>, <I as IsQuery>::ParQueryResult<'a>>, <J as IsQuery>::ParQueryResult<'a>>, <K as IsQuery>::ParQueryResult<'a>>, <L as IsQuery>::ParQueryResult<'a>>, fn((((((((((((<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>), <C as IsQuery>::QueryRow<'a>), <D as IsQuery>::QueryRow<'a>), <E as IsQuery>::QueryRow<'a>), <F as IsQuery>::QueryRow<'a>), <G as IsQuery>::QueryRow<'a>), <H as IsQuery>::QueryRow<'a>), <I as IsQuery>::QueryRow<'a>), <J as IsQuery>::QueryRow<'a>), <K as IsQuery>::QueryRow<'a>), <L as IsQuery>::QueryRow<'a>)) -> (<A as IsQuery>::QueryRow<'a>, <B as IsQuery>::QueryRow<'a>, <C as IsQuery>::QueryRow<'a>, <D as IsQuery>::QueryRow<'a>, <E as IsQuery>::QueryRow<'a>, <F as IsQuery>::QueryRow<'a>, <G as IsQuery>::QueryRow<'a>, <H as IsQuery>::QueryRow<'a>, <I as IsQuery>::QueryRow<'a>, <J as IsQuery>::QueryRow<'a>, <K as IsQuery>::QueryRow<'a>, <L as IsQuery>::QueryRow<'a>)>

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

fn reads() -> Vec<TypeKey>

fn writes() -> Vec<TypeKey>

fn lock_columns<'t>(arch: &'t Archetype) -> Self::LockedColumns<'t>

fn extend_locked_columns<'a, 'b>( (n0, n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11): &'b mut Self::LockedColumns<'a>, (m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11): Self::ExtensionColumns, output_ids: Option<(&mut Vec<usize>, &mut usize)>, )

fn iter_mut<'a, 'b>( (n0, n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11): &'b mut Self::LockedColumns<'a>, ) -> Self::QueryResult<'b>

fn iter_one<'a, 'b>( (n0, n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11): &'b mut Self::LockedColumns<'a>, index: usize, ) -> Self::QueryResult<'b>

fn par_iter_mut<'a, 'b>( len: usize, (n0, n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11): &'b mut Self::LockedColumns<'a>, ) -> Self::ParQueryResult<'b>

Implementors

impl<'s, T: Send + Sync + 'static> IsQuery for Maybe<&'s T>

type LockedColumns<'a> = Option<RwLockReadGuard<'a, RawRwLock, AnyVec<dyn Sync + Send>>>

type ExtensionColumns = ()

type QueryResult<'a> = Either<RepeatWith<fn() -> Option<&'a Entry<T>>>, Map<Iter<'a, Entry<T>>, for<'r> fn(&'r Entry<T>) -> Option<&'r Entry<T>>>>

type ParQueryResult<'a> = Either<Map<RepeatN<()>, fn(()) -> Option<&'a Entry<T>>>, Map<Iter<'a, Entry<T>>, for<'r> fn(&'r Entry<T>) -> Option<&'r Entry<T>>>>

type QueryRow<'a> = Option<&'a Entry<T>>

impl<'s, T: Send + Sync + 'static> IsQuery for Maybe<&'s mut T>

type LockedColumns<'a> = Option<RwLockWriteGuard<'a, RawRwLock, AnyVec<dyn Sync + Send>>>

type ExtensionColumns = ()

type QueryResult<'a> = Either<RepeatWith<fn() -> Option<&'a mut Entry<T>>>, Map<IterMut<'a, Entry<T>>, for<'r> fn(&'r mut Entry<T>) -> Option<&'r mut Entry<T>>>>

type ParQueryResult<'a> = Either<Map<RepeatN<()>, fn(()) -> Option<&'a mut Entry<T>>>, Map<IterMut<'a, Entry<T>>, for<'r> fn(&'r mut Entry<T>) -> Option<&'r mut Entry<T>>>>

type QueryRow<'a> = Option<&'a mut Entry<T>>

impl<T: Send + Sync + 'static> IsQuery for Without<T>

type LockedColumns<'a> = bool

type ExtensionColumns = ()

type QueryResult<'a> = Either<Repeat<()>, IntoIter<()>>

type ParQueryResult<'a> = RepeatN<()>

type QueryRow<'a> = ()