Struct AnyOf 

pub struct AnyOf<T>(/* private fields */);

The AnyOf query parameter fetches entities with any of the component types included in T.

Query<AnyOf<(&A, &B, &mut C)>> is equivalent to Query<(Option<&A>, Option<&B>, Option<&mut C>), Or<(With<A>, With<B>, With<C>)>>. Each of the components in T is returned as an Option, as with Option<A> queries. Entities are guaranteed to have at least one of the components in T.

Trait Implementations

impl ContiguousQueryData for AnyOf<()>

type Contiguous<'w, 's> = ()

Item returned by ContiguousQueryData::fetch_contiguous. Represents a contiguous chunk of memory.

unsafe fn fetch_contiguous<'w, 's>( state: &'s <AnyOf<()> as WorldQuery>::State, fetch: &mut <AnyOf<()> as WorldQuery>::Fetch<'w>, entities: &'w [Entity], ) -> <AnyOf<()> as ContiguousQueryData>::Contiguous<'w, 's>

Fetch ContiguousQueryData::Contiguous which represents a contiguous chunk of memory (e.g., an array) in the current Table. This must always be called after WorldQuery::set_table.

impl<F> ContiguousQueryData for AnyOf<(F,)>

where F: ContiguousQueryData,

type Contiguous<'w, 's> = (Option<<F as ContiguousQueryData>::Contiguous<'w, 's>>,)

Item returned by ContiguousQueryData::fetch_contiguous. Represents a contiguous chunk of memory.

unsafe fn fetch_contiguous<'w, 's>( state: &'s <AnyOf<(F,)> as WorldQuery>::State, fetch: &mut <AnyOf<(F,)> as WorldQuery>::Fetch<'w>, entities: &'w [Entity], ) -> <AnyOf<(F,)> as ContiguousQueryData>::Contiguous<'w, 's>

Fetch ContiguousQueryData::Contiguous which represents a contiguous chunk of memory (e.g., an array) in the current Table. This must always be called after WorldQuery::set_table.

impl<F0, F1> ContiguousQueryData for AnyOf<(F0, F1)>

where F0: ContiguousQueryData, F1: ContiguousQueryData,

type Contiguous<'w, 's> = (Option<<F0 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F1 as ContiguousQueryData>::Contiguous<'w, 's>>)

Item returned by ContiguousQueryData::fetch_contiguous. Represents a contiguous chunk of memory.

unsafe fn fetch_contiguous<'w, 's>( state: &'s <AnyOf<(F0, F1)> as WorldQuery>::State, fetch: &mut <AnyOf<(F0, F1)> as WorldQuery>::Fetch<'w>, entities: &'w [Entity], ) -> <AnyOf<(F0, F1)> as ContiguousQueryData>::Contiguous<'w, 's>

Fetch ContiguousQueryData::Contiguous which represents a contiguous chunk of memory (e.g., an array) in the current Table. This must always be called after WorldQuery::set_table.

impl<F0, F1, F2> ContiguousQueryData for AnyOf<(F0, F1, F2)>

where F0: ContiguousQueryData, F1: ContiguousQueryData, F2: ContiguousQueryData,

type Contiguous<'w, 's> = (Option<<F0 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F1 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F2 as ContiguousQueryData>::Contiguous<'w, 's>>)

Item returned by ContiguousQueryData::fetch_contiguous. Represents a contiguous chunk of memory.

unsafe fn fetch_contiguous<'w, 's>( state: &'s <AnyOf<(F0, F1, F2)> as WorldQuery>::State, fetch: &mut <AnyOf<(F0, F1, F2)> as WorldQuery>::Fetch<'w>, entities: &'w [Entity], ) -> <AnyOf<(F0, F1, F2)> as ContiguousQueryData>::Contiguous<'w, 's>

Fetch ContiguousQueryData::Contiguous which represents a contiguous chunk of memory (e.g., an array) in the current Table. This must always be called after WorldQuery::set_table.

impl<F0, F1, F2, F3> ContiguousQueryData for AnyOf<(F0, F1, F2, F3)>

where F0: ContiguousQueryData, F1: ContiguousQueryData, F2: ContiguousQueryData, F3: ContiguousQueryData,

type Contiguous<'w, 's> = (Option<<F0 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F1 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F2 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F3 as ContiguousQueryData>::Contiguous<'w, 's>>)

Item returned by ContiguousQueryData::fetch_contiguous. Represents a contiguous chunk of memory.

unsafe fn fetch_contiguous<'w, 's>( state: &'s <AnyOf<(F0, F1, F2, F3)> as WorldQuery>::State, fetch: &mut <AnyOf<(F0, F1, F2, F3)> as WorldQuery>::Fetch<'w>, entities: &'w [Entity], ) -> <AnyOf<(F0, F1, F2, F3)> as ContiguousQueryData>::Contiguous<'w, 's>

Fetch ContiguousQueryData::Contiguous which represents a contiguous chunk of memory (e.g., an array) in the current Table. This must always be called after WorldQuery::set_table.

impl<F0, F1, F2, F3, F4> ContiguousQueryData for AnyOf<(F0, F1, F2, F3, F4)>

where F0: ContiguousQueryData, F1: ContiguousQueryData, F2: ContiguousQueryData, F3: ContiguousQueryData, F4: ContiguousQueryData,

type Contiguous<'w, 's> = (Option<<F0 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F1 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F2 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F3 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F4 as ContiguousQueryData>::Contiguous<'w, 's>>)

Item returned by ContiguousQueryData::fetch_contiguous. Represents a contiguous chunk of memory.

unsafe fn fetch_contiguous<'w, 's>( state: &'s <AnyOf<(F0, F1, F2, F3, F4)> as WorldQuery>::State, fetch: &mut <AnyOf<(F0, F1, F2, F3, F4)> as WorldQuery>::Fetch<'w>, entities: &'w [Entity], ) -> <AnyOf<(F0, F1, F2, F3, F4)> as ContiguousQueryData>::Contiguous<'w, 's>

Fetch ContiguousQueryData::Contiguous which represents a contiguous chunk of memory (e.g., an array) in the current Table. This must always be called after WorldQuery::set_table.

impl<F0, F1, F2, F3, F4, F5> ContiguousQueryData for AnyOf<(F0, F1, F2, F3, F4, F5)>

where F0: ContiguousQueryData, F1: ContiguousQueryData, F2: ContiguousQueryData, F3: ContiguousQueryData, F4: ContiguousQueryData, F5: ContiguousQueryData,

type Contiguous<'w, 's> = (Option<<F0 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F1 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F2 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F3 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F4 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F5 as ContiguousQueryData>::Contiguous<'w, 's>>)

Item returned by ContiguousQueryData::fetch_contiguous. Represents a contiguous chunk of memory.

unsafe fn fetch_contiguous<'w, 's>( state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5)> as WorldQuery>::State, fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5)> as WorldQuery>::Fetch<'w>, entities: &'w [Entity], ) -> <AnyOf<(F0, F1, F2, F3, F4, F5)> as ContiguousQueryData>::Contiguous<'w, 's>

Fetch ContiguousQueryData::Contiguous which represents a contiguous chunk of memory (e.g., an array) in the current Table. This must always be called after WorldQuery::set_table.

impl<F0, F1, F2, F3, F4, F5, F6> ContiguousQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6)>

where F0: ContiguousQueryData, F1: ContiguousQueryData, F2: ContiguousQueryData, F3: ContiguousQueryData, F4: ContiguousQueryData, F5: ContiguousQueryData, F6: ContiguousQueryData,

type Contiguous<'w, 's> = (Option<<F0 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F1 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F2 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F3 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F4 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F5 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F6 as ContiguousQueryData>::Contiguous<'w, 's>>)

Item returned by ContiguousQueryData::fetch_contiguous. Represents a contiguous chunk of memory.

unsafe fn fetch_contiguous<'w, 's>( state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6)> as WorldQuery>::State, fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6)> as WorldQuery>::Fetch<'w>, entities: &'w [Entity], ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6)> as ContiguousQueryData>::Contiguous<'w, 's>

Fetch ContiguousQueryData::Contiguous which represents a contiguous chunk of memory (e.g., an array) in the current Table. This must always be called after WorldQuery::set_table.

impl<F0, F1, F2, F3, F4, F5, F6, F7> ContiguousQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)>

where F0: ContiguousQueryData, F1: ContiguousQueryData, F2: ContiguousQueryData, F3: ContiguousQueryData, F4: ContiguousQueryData, F5: ContiguousQueryData, F6: ContiguousQueryData, F7: ContiguousQueryData,

type Contiguous<'w, 's> = (Option<<F0 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F1 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F2 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F3 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F4 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F5 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F6 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F7 as ContiguousQueryData>::Contiguous<'w, 's>>)

Item returned by ContiguousQueryData::fetch_contiguous. Represents a contiguous chunk of memory.

unsafe fn fetch_contiguous<'w, 's>( state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)> as WorldQuery>::State, fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)> as WorldQuery>::Fetch<'w>, entities: &'w [Entity], ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)> as ContiguousQueryData>::Contiguous<'w, 's>

Fetch ContiguousQueryData::Contiguous which represents a contiguous chunk of memory (e.g., an array) in the current Table. This must always be called after WorldQuery::set_table.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8> ContiguousQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)>

where F0: ContiguousQueryData, F1: ContiguousQueryData, F2: ContiguousQueryData, F3: ContiguousQueryData, F4: ContiguousQueryData, F5: ContiguousQueryData, F6: ContiguousQueryData, F7: ContiguousQueryData, F8: ContiguousQueryData,

type Contiguous<'w, 's> = (Option<<F0 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F1 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F2 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F3 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F4 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F5 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F6 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F7 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F8 as ContiguousQueryData>::Contiguous<'w, 's>>)

Item returned by ContiguousQueryData::fetch_contiguous. Represents a contiguous chunk of memory.

unsafe fn fetch_contiguous<'w, 's>( state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> as WorldQuery>::State, fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> as WorldQuery>::Fetch<'w>, entities: &'w [Entity], ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> as ContiguousQueryData>::Contiguous<'w, 's>

Fetch ContiguousQueryData::Contiguous which represents a contiguous chunk of memory (e.g., an array) in the current Table. This must always be called after WorldQuery::set_table.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> ContiguousQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)>

where F0: ContiguousQueryData, F1: ContiguousQueryData, F2: ContiguousQueryData, F3: ContiguousQueryData, F4: ContiguousQueryData, F5: ContiguousQueryData, F6: ContiguousQueryData, F7: ContiguousQueryData, F8: ContiguousQueryData, F9: ContiguousQueryData,

type Contiguous<'w, 's> = (Option<<F0 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F1 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F2 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F3 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F4 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F5 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F6 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F7 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F8 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F9 as ContiguousQueryData>::Contiguous<'w, 's>>)

Item returned by ContiguousQueryData::fetch_contiguous. Represents a contiguous chunk of memory.

unsafe fn fetch_contiguous<'w, 's>( state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> as WorldQuery>::State, fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> as WorldQuery>::Fetch<'w>, entities: &'w [Entity], ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> as ContiguousQueryData>::Contiguous<'w, 's>

Fetch ContiguousQueryData::Contiguous which represents a contiguous chunk of memory (e.g., an array) in the current Table. This must always be called after WorldQuery::set_table.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> ContiguousQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)>

where F0: ContiguousQueryData, F1: ContiguousQueryData, F2: ContiguousQueryData, F3: ContiguousQueryData, F4: ContiguousQueryData, F5: ContiguousQueryData, F6: ContiguousQueryData, F7: ContiguousQueryData, F8: ContiguousQueryData, F9: ContiguousQueryData, F10: ContiguousQueryData,

type Contiguous<'w, 's> = (Option<<F0 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F1 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F2 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F3 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F4 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F5 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F6 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F7 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F8 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F9 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F10 as ContiguousQueryData>::Contiguous<'w, 's>>)

Item returned by ContiguousQueryData::fetch_contiguous. Represents a contiguous chunk of memory.

unsafe fn fetch_contiguous<'w, 's>( state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> as WorldQuery>::State, fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> as WorldQuery>::Fetch<'w>, entities: &'w [Entity], ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> as ContiguousQueryData>::Contiguous<'w, 's>

Fetch ContiguousQueryData::Contiguous which represents a contiguous chunk of memory (e.g., an array) in the current Table. This must always be called after WorldQuery::set_table.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> ContiguousQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)>

where F0: ContiguousQueryData, F1: ContiguousQueryData, F2: ContiguousQueryData, F3: ContiguousQueryData, F4: ContiguousQueryData, F5: ContiguousQueryData, F6: ContiguousQueryData, F7: ContiguousQueryData, F8: ContiguousQueryData, F9: ContiguousQueryData, F10: ContiguousQueryData, F11: ContiguousQueryData,

type Contiguous<'w, 's> = (Option<<F0 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F1 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F2 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F3 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F4 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F5 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F6 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F7 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F8 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F9 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F10 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F11 as ContiguousQueryData>::Contiguous<'w, 's>>)

Item returned by ContiguousQueryData::fetch_contiguous. Represents a contiguous chunk of memory.

unsafe fn fetch_contiguous<'w, 's>( state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> as WorldQuery>::State, fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> as WorldQuery>::Fetch<'w>, entities: &'w [Entity], ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> as ContiguousQueryData>::Contiguous<'w, 's>

Fetch ContiguousQueryData::Contiguous which represents a contiguous chunk of memory (e.g., an array) in the current Table. This must always be called after WorldQuery::set_table.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12> ContiguousQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)>

where F0: ContiguousQueryData, F1: ContiguousQueryData, F2: ContiguousQueryData, F3: ContiguousQueryData, F4: ContiguousQueryData, F5: ContiguousQueryData, F6: ContiguousQueryData, F7: ContiguousQueryData, F8: ContiguousQueryData, F9: ContiguousQueryData, F10: ContiguousQueryData, F11: ContiguousQueryData, F12: ContiguousQueryData,

type Contiguous<'w, 's> = (Option<<F0 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F1 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F2 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F3 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F4 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F5 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F6 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F7 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F8 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F9 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F10 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F11 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F12 as ContiguousQueryData>::Contiguous<'w, 's>>)

Item returned by ContiguousQueryData::fetch_contiguous. Represents a contiguous chunk of memory.

unsafe fn fetch_contiguous<'w, 's>( state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> as WorldQuery>::State, fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> as WorldQuery>::Fetch<'w>, entities: &'w [Entity], ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> as ContiguousQueryData>::Contiguous<'w, 's>

Fetch ContiguousQueryData::Contiguous which represents a contiguous chunk of memory (e.g., an array) in the current Table. This must always be called after WorldQuery::set_table.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13> ContiguousQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)>

where F0: ContiguousQueryData, F1: ContiguousQueryData, F2: ContiguousQueryData, F3: ContiguousQueryData, F4: ContiguousQueryData, F5: ContiguousQueryData, F6: ContiguousQueryData, F7: ContiguousQueryData, F8: ContiguousQueryData, F9: ContiguousQueryData, F10: ContiguousQueryData, F11: ContiguousQueryData, F12: ContiguousQueryData, F13: ContiguousQueryData,

type Contiguous<'w, 's> = (Option<<F0 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F1 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F2 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F3 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F4 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F5 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F6 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F7 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F8 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F9 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F10 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F11 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F12 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F13 as ContiguousQueryData>::Contiguous<'w, 's>>)

Item returned by ContiguousQueryData::fetch_contiguous. Represents a contiguous chunk of memory.

unsafe fn fetch_contiguous<'w, 's>( state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> as WorldQuery>::State, fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> as WorldQuery>::Fetch<'w>, entities: &'w [Entity], ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> as ContiguousQueryData>::Contiguous<'w, 's>

Fetch ContiguousQueryData::Contiguous which represents a contiguous chunk of memory (e.g., an array) in the current Table. This must always be called after WorldQuery::set_table.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14> ContiguousQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)>

where F0: ContiguousQueryData, F1: ContiguousQueryData, F2: ContiguousQueryData, F3: ContiguousQueryData, F4: ContiguousQueryData, F5: ContiguousQueryData, F6: ContiguousQueryData, F7: ContiguousQueryData, F8: ContiguousQueryData, F9: ContiguousQueryData, F10: ContiguousQueryData, F11: ContiguousQueryData, F12: ContiguousQueryData, F13: ContiguousQueryData, F14: ContiguousQueryData,

type Contiguous<'w, 's> = (Option<<F0 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F1 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F2 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F3 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F4 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F5 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F6 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F7 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F8 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F9 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F10 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F11 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F12 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F13 as ContiguousQueryData>::Contiguous<'w, 's>>, Option<<F14 as ContiguousQueryData>::Contiguous<'w, 's>>)

Item returned by ContiguousQueryData::fetch_contiguous. Represents a contiguous chunk of memory.

unsafe fn fetch_contiguous<'w, 's>( state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> as WorldQuery>::State, fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> as WorldQuery>::Fetch<'w>, entities: &'w [Entity], ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> as ContiguousQueryData>::Contiguous<'w, 's>

Fetch ContiguousQueryData::Contiguous which represents a contiguous chunk of memory (e.g., an array) in the current Table. This must always be called after WorldQuery::set_table.

impl QueryData for AnyOf<()>

const IS_READ_ONLY: bool = true

True if this query is read-only and may not perform mutable access.

const IS_ARCHETYPAL: bool = true

Returns true if (and only if) this query data relies strictly on archetypes to limit which entities are accessed by the Query.

type ReadOnly = AnyOf<()>

The read-only variant of this QueryData, which satisfies the ReadOnlyQueryData trait.

type Item<'w, 's> = ()

The item returned by this WorldQuery This will be the data retrieved by the query, and is visible to the end user when calling e.g. Query<Self>::get.

fn shrink<'wlong, 'wshort, 's>( item: <AnyOf<()> as QueryData>::Item<'wlong, 's>, ) -> <AnyOf<()> as QueryData>::Item<'wshort, 's>

where 'wlong: 'wshort,

This function manually implements subtyping for the query items.

unsafe fn fetch<'w, 's>( _state: &'s <AnyOf<()> as WorldQuery>::State, _fetch: &mut <AnyOf<()> as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Option<<AnyOf<()> as QueryData>::Item<'w, 's>>

Fetch Self::Item for either the given entity in the current Table, or for the given entity in the current Archetype. This must always be called after WorldQuery::set_table with a table_row in the range of the current Table or after WorldQuery::set_archetype with an entity in the current archetype. Accesses components registered in WorldQuery::update_component_access.

fn iter_access( state: &<AnyOf<()> as WorldQuery>::State, ) -> impl Iterator<Item = EcsAccessType<'_>>

Returns an iterator over the access needed by QueryData::fetch. Access conflicts are usually checked in WorldQuery::update_component_access, but in certain cases this method can be useful to implement a way of checking for access conflicts in a non-allocating way.

fn provide_extra_access( _state: &mut Self::State, _access: &mut Access, _available_access: &Access, )

Offers additional access above what we requested in update_component_access. Implementations may add additional access that is a subset of available_access and does not conflict with anything in access, and must update access to include that access.

impl<F> QueryData for AnyOf<(F,)>

where F: QueryData,

const IS_READ_ONLY: bool

True if this query is read-only and may not perform mutable access.

const IS_ARCHETYPAL: bool

Returns true if (and only if) this query data relies strictly on archetypes to limit which entities are accessed by the Query.

type ReadOnly = AnyOf<(<F as QueryData>::ReadOnly,)>

The read-only variant of this QueryData, which satisfies the ReadOnlyQueryData trait.

type Item<'w, 's> = (Option<<F as QueryData>::Item<'w, 's>>,)

The item returned by this WorldQuery This will be the data retrieved by the query, and is visible to the end user when calling e.g. Query<Self>::get.

fn shrink<'wlong, 'wshort, 's>( item: <AnyOf<(F,)> as QueryData>::Item<'wlong, 's>, ) -> <AnyOf<(F,)> as QueryData>::Item<'wshort, 's>

where 'wlong: 'wshort,

This function manually implements subtyping for the query items.

unsafe fn fetch<'w, 's>( _state: &'s <AnyOf<(F,)> as WorldQuery>::State, _fetch: &mut <AnyOf<(F,)> as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Option<<AnyOf<(F,)> as QueryData>::Item<'w, 's>>

Fetch Self::Item for either the given entity in the current Table, or for the given entity in the current Archetype. This must always be called after WorldQuery::set_table with a table_row in the range of the current Table or after WorldQuery::set_archetype with an entity in the current archetype. Accesses components registered in WorldQuery::update_component_access.

fn iter_access( state: &<AnyOf<(F,)> as WorldQuery>::State, ) -> impl Iterator<Item = EcsAccessType<'_>>

Returns an iterator over the access needed by QueryData::fetch. Access conflicts are usually checked in WorldQuery::update_component_access, but in certain cases this method can be useful to implement a way of checking for access conflicts in a non-allocating way.

fn provide_extra_access( _state: &mut Self::State, _access: &mut Access, _available_access: &Access, )

Offers additional access above what we requested in update_component_access. Implementations may add additional access that is a subset of available_access and does not conflict with anything in access, and must update access to include that access.

impl<F0, F1> QueryData for AnyOf<(F0, F1)>

where F0: QueryData, F1: QueryData,

const IS_READ_ONLY: bool

True if this query is read-only and may not perform mutable access.

const IS_ARCHETYPAL: bool

Returns true if (and only if) this query data relies strictly on archetypes to limit which entities are accessed by the Query.

type ReadOnly = AnyOf<(<F0 as QueryData>::ReadOnly, <F1 as QueryData>::ReadOnly)>

The read-only variant of this QueryData, which satisfies the ReadOnlyQueryData trait.

type Item<'w, 's> = (Option<<F0 as QueryData>::Item<'w, 's>>, Option<<F1 as QueryData>::Item<'w, 's>>)

The item returned by this WorldQuery This will be the data retrieved by the query, and is visible to the end user when calling e.g. Query<Self>::get.

fn shrink<'wlong, 'wshort, 's>( item: <AnyOf<(F0, F1)> as QueryData>::Item<'wlong, 's>, ) -> <AnyOf<(F0, F1)> as QueryData>::Item<'wshort, 's>

where 'wlong: 'wshort,

This function manually implements subtyping for the query items.

unsafe fn fetch<'w, 's>( _state: &'s <AnyOf<(F0, F1)> as WorldQuery>::State, _fetch: &mut <AnyOf<(F0, F1)> as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Option<<AnyOf<(F0, F1)> as QueryData>::Item<'w, 's>>

Fetch Self::Item for either the given entity in the current Table, or for the given entity in the current Archetype. This must always be called after WorldQuery::set_table with a table_row in the range of the current Table or after WorldQuery::set_archetype with an entity in the current archetype. Accesses components registered in WorldQuery::update_component_access.

fn iter_access( state: &<AnyOf<(F0, F1)> as WorldQuery>::State, ) -> impl Iterator<Item = EcsAccessType<'_>>

Returns an iterator over the access needed by QueryData::fetch. Access conflicts are usually checked in WorldQuery::update_component_access, but in certain cases this method can be useful to implement a way of checking for access conflicts in a non-allocating way.

fn provide_extra_access( _state: &mut Self::State, _access: &mut Access, _available_access: &Access, )

Offers additional access above what we requested in update_component_access. Implementations may add additional access that is a subset of available_access and does not conflict with anything in access, and must update access to include that access.

impl<F0, F1, F2> QueryData for AnyOf<(F0, F1, F2)>

where F0: QueryData, F1: QueryData, F2: QueryData,

const IS_READ_ONLY: bool

True if this query is read-only and may not perform mutable access.

const IS_ARCHETYPAL: bool

Returns true if (and only if) this query data relies strictly on archetypes to limit which entities are accessed by the Query.

type ReadOnly = AnyOf<(<F0 as QueryData>::ReadOnly, <F1 as QueryData>::ReadOnly, <F2 as QueryData>::ReadOnly)>

The read-only variant of this QueryData, which satisfies the ReadOnlyQueryData trait.

type Item<'w, 's> = (Option<<F0 as QueryData>::Item<'w, 's>>, Option<<F1 as QueryData>::Item<'w, 's>>, Option<<F2 as QueryData>::Item<'w, 's>>)

The item returned by this WorldQuery This will be the data retrieved by the query, and is visible to the end user when calling e.g. Query<Self>::get.

fn shrink<'wlong, 'wshort, 's>( item: <AnyOf<(F0, F1, F2)> as QueryData>::Item<'wlong, 's>, ) -> <AnyOf<(F0, F1, F2)> as QueryData>::Item<'wshort, 's>

where 'wlong: 'wshort,

This function manually implements subtyping for the query items.

unsafe fn fetch<'w, 's>( _state: &'s <AnyOf<(F0, F1, F2)> as WorldQuery>::State, _fetch: &mut <AnyOf<(F0, F1, F2)> as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Option<<AnyOf<(F0, F1, F2)> as QueryData>::Item<'w, 's>>

Fetch Self::Item for either the given entity in the current Table, or for the given entity in the current Archetype. This must always be called after WorldQuery::set_table with a table_row in the range of the current Table or after WorldQuery::set_archetype with an entity in the current archetype. Accesses components registered in WorldQuery::update_component_access.

fn iter_access( state: &<AnyOf<(F0, F1, F2)> as WorldQuery>::State, ) -> impl Iterator<Item = EcsAccessType<'_>>

Returns an iterator over the access needed by QueryData::fetch. Access conflicts are usually checked in WorldQuery::update_component_access, but in certain cases this method can be useful to implement a way of checking for access conflicts in a non-allocating way.

fn provide_extra_access( _state: &mut Self::State, _access: &mut Access, _available_access: &Access, )

Offers additional access above what we requested in update_component_access. Implementations may add additional access that is a subset of available_access and does not conflict with anything in access, and must update access to include that access.

impl<F0, F1, F2, F3> QueryData for AnyOf<(F0, F1, F2, F3)>

where F0: QueryData, F1: QueryData, F2: QueryData, F3: QueryData,

const IS_READ_ONLY: bool

True if this query is read-only and may not perform mutable access.

const IS_ARCHETYPAL: bool

Returns true if (and only if) this query data relies strictly on archetypes to limit which entities are accessed by the Query.

type ReadOnly = AnyOf<(<F0 as QueryData>::ReadOnly, <F1 as QueryData>::ReadOnly, <F2 as QueryData>::ReadOnly, <F3 as QueryData>::ReadOnly)>

The read-only variant of this QueryData, which satisfies the ReadOnlyQueryData trait.

type Item<'w, 's> = (Option<<F0 as QueryData>::Item<'w, 's>>, Option<<F1 as QueryData>::Item<'w, 's>>, Option<<F2 as QueryData>::Item<'w, 's>>, Option<<F3 as QueryData>::Item<'w, 's>>)

The item returned by this WorldQuery This will be the data retrieved by the query, and is visible to the end user when calling e.g. Query<Self>::get.

fn shrink<'wlong, 'wshort, 's>( item: <AnyOf<(F0, F1, F2, F3)> as QueryData>::Item<'wlong, 's>, ) -> <AnyOf<(F0, F1, F2, F3)> as QueryData>::Item<'wshort, 's>

where 'wlong: 'wshort,

This function manually implements subtyping for the query items.

unsafe fn fetch<'w, 's>( _state: &'s <AnyOf<(F0, F1, F2, F3)> as WorldQuery>::State, _fetch: &mut <AnyOf<(F0, F1, F2, F3)> as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Option<<AnyOf<(F0, F1, F2, F3)> as QueryData>::Item<'w, 's>>

Fetch Self::Item for either the given entity in the current Table, or for the given entity in the current Archetype. This must always be called after WorldQuery::set_table with a table_row in the range of the current Table or after WorldQuery::set_archetype with an entity in the current archetype. Accesses components registered in WorldQuery::update_component_access.

fn iter_access( state: &<AnyOf<(F0, F1, F2, F3)> as WorldQuery>::State, ) -> impl Iterator<Item = EcsAccessType<'_>>

Returns an iterator over the access needed by QueryData::fetch. Access conflicts are usually checked in WorldQuery::update_component_access, but in certain cases this method can be useful to implement a way of checking for access conflicts in a non-allocating way.

fn provide_extra_access( _state: &mut Self::State, _access: &mut Access, _available_access: &Access, )

Offers additional access above what we requested in update_component_access. Implementations may add additional access that is a subset of available_access and does not conflict with anything in access, and must update access to include that access.

impl<F0, F1, F2, F3, F4> QueryData for AnyOf<(F0, F1, F2, F3, F4)>

where F0: QueryData, F1: QueryData, F2: QueryData, F3: QueryData, F4: QueryData,

const IS_READ_ONLY: bool

True if this query is read-only and may not perform mutable access.

const IS_ARCHETYPAL: bool

Returns true if (and only if) this query data relies strictly on archetypes to limit which entities are accessed by the Query.

type ReadOnly = AnyOf<(<F0 as QueryData>::ReadOnly, <F1 as QueryData>::ReadOnly, <F2 as QueryData>::ReadOnly, <F3 as QueryData>::ReadOnly, <F4 as QueryData>::ReadOnly)>

The read-only variant of this QueryData, which satisfies the ReadOnlyQueryData trait.

type Item<'w, 's> = (Option<<F0 as QueryData>::Item<'w, 's>>, Option<<F1 as QueryData>::Item<'w, 's>>, Option<<F2 as QueryData>::Item<'w, 's>>, Option<<F3 as QueryData>::Item<'w, 's>>, Option<<F4 as QueryData>::Item<'w, 's>>)

The item returned by this WorldQuery This will be the data retrieved by the query, and is visible to the end user when calling e.g. Query<Self>::get.

fn shrink<'wlong, 'wshort, 's>( item: <AnyOf<(F0, F1, F2, F3, F4)> as QueryData>::Item<'wlong, 's>, ) -> <AnyOf<(F0, F1, F2, F3, F4)> as QueryData>::Item<'wshort, 's>

where 'wlong: 'wshort,

This function manually implements subtyping for the query items.

unsafe fn fetch<'w, 's>( _state: &'s <AnyOf<(F0, F1, F2, F3, F4)> as WorldQuery>::State, _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4)> as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Option<<AnyOf<(F0, F1, F2, F3, F4)> as QueryData>::Item<'w, 's>>

Fetch Self::Item for either the given entity in the current Table, or for the given entity in the current Archetype. This must always be called after WorldQuery::set_table with a table_row in the range of the current Table or after WorldQuery::set_archetype with an entity in the current archetype. Accesses components registered in WorldQuery::update_component_access.

fn iter_access( state: &<AnyOf<(F0, F1, F2, F3, F4)> as WorldQuery>::State, ) -> impl Iterator<Item = EcsAccessType<'_>>

Returns an iterator over the access needed by QueryData::fetch. Access conflicts are usually checked in WorldQuery::update_component_access, but in certain cases this method can be useful to implement a way of checking for access conflicts in a non-allocating way.

fn provide_extra_access( _state: &mut Self::State, _access: &mut Access, _available_access: &Access, )

Offers additional access above what we requested in update_component_access. Implementations may add additional access that is a subset of available_access and does not conflict with anything in access, and must update access to include that access.

impl<F0, F1, F2, F3, F4, F5> QueryData for AnyOf<(F0, F1, F2, F3, F4, F5)>

where F0: QueryData, F1: QueryData, F2: QueryData, F3: QueryData, F4: QueryData, F5: QueryData,

const IS_READ_ONLY: bool

True if this query is read-only and may not perform mutable access.

const IS_ARCHETYPAL: bool

Returns true if (and only if) this query data relies strictly on archetypes to limit which entities are accessed by the Query.

type ReadOnly = AnyOf<(<F0 as QueryData>::ReadOnly, <F1 as QueryData>::ReadOnly, <F2 as QueryData>::ReadOnly, <F3 as QueryData>::ReadOnly, <F4 as QueryData>::ReadOnly, <F5 as QueryData>::ReadOnly)>

The read-only variant of this QueryData, which satisfies the ReadOnlyQueryData trait.

type Item<'w, 's> = (Option<<F0 as QueryData>::Item<'w, 's>>, Option<<F1 as QueryData>::Item<'w, 's>>, Option<<F2 as QueryData>::Item<'w, 's>>, Option<<F3 as QueryData>::Item<'w, 's>>, Option<<F4 as QueryData>::Item<'w, 's>>, Option<<F5 as QueryData>::Item<'w, 's>>)

The item returned by this WorldQuery This will be the data retrieved by the query, and is visible to the end user when calling e.g. Query<Self>::get.

fn shrink<'wlong, 'wshort, 's>( item: <AnyOf<(F0, F1, F2, F3, F4, F5)> as QueryData>::Item<'wlong, 's>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5)> as QueryData>::Item<'wshort, 's>

where 'wlong: 'wshort,

This function manually implements subtyping for the query items.

unsafe fn fetch<'w, 's>( _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5)> as WorldQuery>::State, _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5)> as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Option<<AnyOf<(F0, F1, F2, F3, F4, F5)> as QueryData>::Item<'w, 's>>

Fetch Self::Item for either the given entity in the current Table, or for the given entity in the current Archetype. This must always be called after WorldQuery::set_table with a table_row in the range of the current Table or after WorldQuery::set_archetype with an entity in the current archetype. Accesses components registered in WorldQuery::update_component_access.

fn iter_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5)> as WorldQuery>::State, ) -> impl Iterator<Item = EcsAccessType<'_>>

Returns an iterator over the access needed by QueryData::fetch. Access conflicts are usually checked in WorldQuery::update_component_access, but in certain cases this method can be useful to implement a way of checking for access conflicts in a non-allocating way.

fn provide_extra_access( _state: &mut Self::State, _access: &mut Access, _available_access: &Access, )

Offers additional access above what we requested in update_component_access. Implementations may add additional access that is a subset of available_access and does not conflict with anything in access, and must update access to include that access.

impl<F0, F1, F2, F3, F4, F5, F6> QueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6)>

where F0: QueryData, F1: QueryData, F2: QueryData, F3: QueryData, F4: QueryData, F5: QueryData, F6: QueryData,

const IS_READ_ONLY: bool

True if this query is read-only and may not perform mutable access.

const IS_ARCHETYPAL: bool

Returns true if (and only if) this query data relies strictly on archetypes to limit which entities are accessed by the Query.

type ReadOnly = AnyOf<(<F0 as QueryData>::ReadOnly, <F1 as QueryData>::ReadOnly, <F2 as QueryData>::ReadOnly, <F3 as QueryData>::ReadOnly, <F4 as QueryData>::ReadOnly, <F5 as QueryData>::ReadOnly, <F6 as QueryData>::ReadOnly)>

The read-only variant of this QueryData, which satisfies the ReadOnlyQueryData trait.

type Item<'w, 's> = (Option<<F0 as QueryData>::Item<'w, 's>>, Option<<F1 as QueryData>::Item<'w, 's>>, Option<<F2 as QueryData>::Item<'w, 's>>, Option<<F3 as QueryData>::Item<'w, 's>>, Option<<F4 as QueryData>::Item<'w, 's>>, Option<<F5 as QueryData>::Item<'w, 's>>, Option<<F6 as QueryData>::Item<'w, 's>>)

The item returned by this WorldQuery This will be the data retrieved by the query, and is visible to the end user when calling e.g. Query<Self>::get.

fn shrink<'wlong, 'wshort, 's>( item: <AnyOf<(F0, F1, F2, F3, F4, F5, F6)> as QueryData>::Item<'wlong, 's>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6)> as QueryData>::Item<'wshort, 's>

where 'wlong: 'wshort,

This function manually implements subtyping for the query items.

unsafe fn fetch<'w, 's>( _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6)> as WorldQuery>::State, _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6)> as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Option<<AnyOf<(F0, F1, F2, F3, F4, F5, F6)> as QueryData>::Item<'w, 's>>

Fetch Self::Item for either the given entity in the current Table, or for the given entity in the current Archetype. This must always be called after WorldQuery::set_table with a table_row in the range of the current Table or after WorldQuery::set_archetype with an entity in the current archetype. Accesses components registered in WorldQuery::update_component_access.

fn iter_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6)> as WorldQuery>::State, ) -> impl Iterator<Item = EcsAccessType<'_>>

Returns an iterator over the access needed by QueryData::fetch. Access conflicts are usually checked in WorldQuery::update_component_access, but in certain cases this method can be useful to implement a way of checking for access conflicts in a non-allocating way.

fn provide_extra_access( _state: &mut Self::State, _access: &mut Access, _available_access: &Access, )

Offers additional access above what we requested in update_component_access. Implementations may add additional access that is a subset of available_access and does not conflict with anything in access, and must update access to include that access.

impl<F0, F1, F2, F3, F4, F5, F6, F7> QueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)>

where F0: QueryData, F1: QueryData, F2: QueryData, F3: QueryData, F4: QueryData, F5: QueryData, F6: QueryData, F7: QueryData,

const IS_READ_ONLY: bool

True if this query is read-only and may not perform mutable access.

const IS_ARCHETYPAL: bool

Returns true if (and only if) this query data relies strictly on archetypes to limit which entities are accessed by the Query.

type ReadOnly = AnyOf<(<F0 as QueryData>::ReadOnly, <F1 as QueryData>::ReadOnly, <F2 as QueryData>::ReadOnly, <F3 as QueryData>::ReadOnly, <F4 as QueryData>::ReadOnly, <F5 as QueryData>::ReadOnly, <F6 as QueryData>::ReadOnly, <F7 as QueryData>::ReadOnly)>

The read-only variant of this QueryData, which satisfies the ReadOnlyQueryData trait.

type Item<'w, 's> = (Option<<F0 as QueryData>::Item<'w, 's>>, Option<<F1 as QueryData>::Item<'w, 's>>, Option<<F2 as QueryData>::Item<'w, 's>>, Option<<F3 as QueryData>::Item<'w, 's>>, Option<<F4 as QueryData>::Item<'w, 's>>, Option<<F5 as QueryData>::Item<'w, 's>>, Option<<F6 as QueryData>::Item<'w, 's>>, Option<<F7 as QueryData>::Item<'w, 's>>)

The item returned by this WorldQuery This will be the data retrieved by the query, and is visible to the end user when calling e.g. Query<Self>::get.

fn shrink<'wlong, 'wshort, 's>( item: <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)> as QueryData>::Item<'wlong, 's>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)> as QueryData>::Item<'wshort, 's>

where 'wlong: 'wshort,

This function manually implements subtyping for the query items.

unsafe fn fetch<'w, 's>( _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)> as WorldQuery>::State, _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)> as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Option<<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)> as QueryData>::Item<'w, 's>>

Fetch Self::Item for either the given entity in the current Table, or for the given entity in the current Archetype. This must always be called after WorldQuery::set_table with a table_row in the range of the current Table or after WorldQuery::set_archetype with an entity in the current archetype. Accesses components registered in WorldQuery::update_component_access.

fn iter_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)> as WorldQuery>::State, ) -> impl Iterator<Item = EcsAccessType<'_>>

Returns an iterator over the access needed by QueryData::fetch. Access conflicts are usually checked in WorldQuery::update_component_access, but in certain cases this method can be useful to implement a way of checking for access conflicts in a non-allocating way.

fn provide_extra_access( _state: &mut Self::State, _access: &mut Access, _available_access: &Access, )

Offers additional access above what we requested in update_component_access. Implementations may add additional access that is a subset of available_access and does not conflict with anything in access, and must update access to include that access.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8> QueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)>

where F0: QueryData, F1: QueryData, F2: QueryData, F3: QueryData, F4: QueryData, F5: QueryData, F6: QueryData, F7: QueryData, F8: QueryData,

const IS_READ_ONLY: bool

True if this query is read-only and may not perform mutable access.

const IS_ARCHETYPAL: bool

Returns true if (and only if) this query data relies strictly on archetypes to limit which entities are accessed by the Query.

type ReadOnly = AnyOf<(<F0 as QueryData>::ReadOnly, <F1 as QueryData>::ReadOnly, <F2 as QueryData>::ReadOnly, <F3 as QueryData>::ReadOnly, <F4 as QueryData>::ReadOnly, <F5 as QueryData>::ReadOnly, <F6 as QueryData>::ReadOnly, <F7 as QueryData>::ReadOnly, <F8 as QueryData>::ReadOnly)>

The read-only variant of this QueryData, which satisfies the ReadOnlyQueryData trait.

type Item<'w, 's> = (Option<<F0 as QueryData>::Item<'w, 's>>, Option<<F1 as QueryData>::Item<'w, 's>>, Option<<F2 as QueryData>::Item<'w, 's>>, Option<<F3 as QueryData>::Item<'w, 's>>, Option<<F4 as QueryData>::Item<'w, 's>>, Option<<F5 as QueryData>::Item<'w, 's>>, Option<<F6 as QueryData>::Item<'w, 's>>, Option<<F7 as QueryData>::Item<'w, 's>>, Option<<F8 as QueryData>::Item<'w, 's>>)

The item returned by this WorldQuery This will be the data retrieved by the query, and is visible to the end user when calling e.g. Query<Self>::get.

fn shrink<'wlong, 'wshort, 's>( item: <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> as QueryData>::Item<'wlong, 's>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> as QueryData>::Item<'wshort, 's>

where 'wlong: 'wshort,

This function manually implements subtyping for the query items.

unsafe fn fetch<'w, 's>( _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> as WorldQuery>::State, _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Option<<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> as QueryData>::Item<'w, 's>>

Fetch Self::Item for either the given entity in the current Table, or for the given entity in the current Archetype. This must always be called after WorldQuery::set_table with a table_row in the range of the current Table or after WorldQuery::set_archetype with an entity in the current archetype. Accesses components registered in WorldQuery::update_component_access.

fn iter_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> as WorldQuery>::State, ) -> impl Iterator<Item = EcsAccessType<'_>>

Returns an iterator over the access needed by QueryData::fetch. Access conflicts are usually checked in WorldQuery::update_component_access, but in certain cases this method can be useful to implement a way of checking for access conflicts in a non-allocating way.

fn provide_extra_access( _state: &mut Self::State, _access: &mut Access, _available_access: &Access, )

Offers additional access above what we requested in update_component_access. Implementations may add additional access that is a subset of available_access and does not conflict with anything in access, and must update access to include that access.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> QueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)>

where F0: QueryData, F1: QueryData, F2: QueryData, F3: QueryData, F4: QueryData, F5: QueryData, F6: QueryData, F7: QueryData, F8: QueryData, F9: QueryData,

const IS_READ_ONLY: bool

True if this query is read-only and may not perform mutable access.

const IS_ARCHETYPAL: bool

Returns true if (and only if) this query data relies strictly on archetypes to limit which entities are accessed by the Query.

type ReadOnly = AnyOf<(<F0 as QueryData>::ReadOnly, <F1 as QueryData>::ReadOnly, <F2 as QueryData>::ReadOnly, <F3 as QueryData>::ReadOnly, <F4 as QueryData>::ReadOnly, <F5 as QueryData>::ReadOnly, <F6 as QueryData>::ReadOnly, <F7 as QueryData>::ReadOnly, <F8 as QueryData>::ReadOnly, <F9 as QueryData>::ReadOnly)>

The read-only variant of this QueryData, which satisfies the ReadOnlyQueryData trait.

type Item<'w, 's> = (Option<<F0 as QueryData>::Item<'w, 's>>, Option<<F1 as QueryData>::Item<'w, 's>>, Option<<F2 as QueryData>::Item<'w, 's>>, Option<<F3 as QueryData>::Item<'w, 's>>, Option<<F4 as QueryData>::Item<'w, 's>>, Option<<F5 as QueryData>::Item<'w, 's>>, Option<<F6 as QueryData>::Item<'w, 's>>, Option<<F7 as QueryData>::Item<'w, 's>>, Option<<F8 as QueryData>::Item<'w, 's>>, Option<<F9 as QueryData>::Item<'w, 's>>)

The item returned by this WorldQuery This will be the data retrieved by the query, and is visible to the end user when calling e.g. Query<Self>::get.

fn shrink<'wlong, 'wshort, 's>( item: <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> as QueryData>::Item<'wlong, 's>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> as QueryData>::Item<'wshort, 's>

where 'wlong: 'wshort,

This function manually implements subtyping for the query items.

unsafe fn fetch<'w, 's>( _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> as WorldQuery>::State, _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Option<<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> as QueryData>::Item<'w, 's>>

Fetch Self::Item for either the given entity in the current Table, or for the given entity in the current Archetype. This must always be called after WorldQuery::set_table with a table_row in the range of the current Table or after WorldQuery::set_archetype with an entity in the current archetype. Accesses components registered in WorldQuery::update_component_access.

fn iter_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> as WorldQuery>::State, ) -> impl Iterator<Item = EcsAccessType<'_>>

Returns an iterator over the access needed by QueryData::fetch. Access conflicts are usually checked in WorldQuery::update_component_access, but in certain cases this method can be useful to implement a way of checking for access conflicts in a non-allocating way.

fn provide_extra_access( _state: &mut Self::State, _access: &mut Access, _available_access: &Access, )

Offers additional access above what we requested in update_component_access. Implementations may add additional access that is a subset of available_access and does not conflict with anything in access, and must update access to include that access.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> QueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)>

where F0: QueryData, F1: QueryData, F2: QueryData, F3: QueryData, F4: QueryData, F5: QueryData, F6: QueryData, F7: QueryData, F8: QueryData, F9: QueryData, F10: QueryData,

const IS_READ_ONLY: bool

True if this query is read-only and may not perform mutable access.

const IS_ARCHETYPAL: bool

Returns true if (and only if) this query data relies strictly on archetypes to limit which entities are accessed by the Query.

type ReadOnly = AnyOf<(<F0 as QueryData>::ReadOnly, <F1 as QueryData>::ReadOnly, <F2 as QueryData>::ReadOnly, <F3 as QueryData>::ReadOnly, <F4 as QueryData>::ReadOnly, <F5 as QueryData>::ReadOnly, <F6 as QueryData>::ReadOnly, <F7 as QueryData>::ReadOnly, <F8 as QueryData>::ReadOnly, <F9 as QueryData>::ReadOnly, <F10 as QueryData>::ReadOnly)>

The read-only variant of this QueryData, which satisfies the ReadOnlyQueryData trait.

type Item<'w, 's> = (Option<<F0 as QueryData>::Item<'w, 's>>, Option<<F1 as QueryData>::Item<'w, 's>>, Option<<F2 as QueryData>::Item<'w, 's>>, Option<<F3 as QueryData>::Item<'w, 's>>, Option<<F4 as QueryData>::Item<'w, 's>>, Option<<F5 as QueryData>::Item<'w, 's>>, Option<<F6 as QueryData>::Item<'w, 's>>, Option<<F7 as QueryData>::Item<'w, 's>>, Option<<F8 as QueryData>::Item<'w, 's>>, Option<<F9 as QueryData>::Item<'w, 's>>, Option<<F10 as QueryData>::Item<'w, 's>>)

The item returned by this WorldQuery This will be the data retrieved by the query, and is visible to the end user when calling e.g. Query<Self>::get.

fn shrink<'wlong, 'wshort, 's>( item: <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> as QueryData>::Item<'wlong, 's>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> as QueryData>::Item<'wshort, 's>

where 'wlong: 'wshort,

This function manually implements subtyping for the query items.

unsafe fn fetch<'w, 's>( _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> as WorldQuery>::State, _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Option<<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> as QueryData>::Item<'w, 's>>

Fetch Self::Item for either the given entity in the current Table, or for the given entity in the current Archetype. This must always be called after WorldQuery::set_table with a table_row in the range of the current Table or after WorldQuery::set_archetype with an entity in the current archetype. Accesses components registered in WorldQuery::update_component_access.

fn iter_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> as WorldQuery>::State, ) -> impl Iterator<Item = EcsAccessType<'_>>

Returns an iterator over the access needed by QueryData::fetch. Access conflicts are usually checked in WorldQuery::update_component_access, but in certain cases this method can be useful to implement a way of checking for access conflicts in a non-allocating way.

fn provide_extra_access( _state: &mut Self::State, _access: &mut Access, _available_access: &Access, )

Offers additional access above what we requested in update_component_access. Implementations may add additional access that is a subset of available_access and does not conflict with anything in access, and must update access to include that access.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> QueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)>

where F0: QueryData, F1: QueryData, F2: QueryData, F3: QueryData, F4: QueryData, F5: QueryData, F6: QueryData, F7: QueryData, F8: QueryData, F9: QueryData, F10: QueryData, F11: QueryData,

const IS_READ_ONLY: bool

True if this query is read-only and may not perform mutable access.

const IS_ARCHETYPAL: bool

Returns true if (and only if) this query data relies strictly on archetypes to limit which entities are accessed by the Query.

type ReadOnly = AnyOf<(<F0 as QueryData>::ReadOnly, <F1 as QueryData>::ReadOnly, <F2 as QueryData>::ReadOnly, <F3 as QueryData>::ReadOnly, <F4 as QueryData>::ReadOnly, <F5 as QueryData>::ReadOnly, <F6 as QueryData>::ReadOnly, <F7 as QueryData>::ReadOnly, <F8 as QueryData>::ReadOnly, <F9 as QueryData>::ReadOnly, <F10 as QueryData>::ReadOnly, <F11 as QueryData>::ReadOnly)>

The read-only variant of this QueryData, which satisfies the ReadOnlyQueryData trait.

type Item<'w, 's> = (Option<<F0 as QueryData>::Item<'w, 's>>, Option<<F1 as QueryData>::Item<'w, 's>>, Option<<F2 as QueryData>::Item<'w, 's>>, Option<<F3 as QueryData>::Item<'w, 's>>, Option<<F4 as QueryData>::Item<'w, 's>>, Option<<F5 as QueryData>::Item<'w, 's>>, Option<<F6 as QueryData>::Item<'w, 's>>, Option<<F7 as QueryData>::Item<'w, 's>>, Option<<F8 as QueryData>::Item<'w, 's>>, Option<<F9 as QueryData>::Item<'w, 's>>, Option<<F10 as QueryData>::Item<'w, 's>>, Option<<F11 as QueryData>::Item<'w, 's>>)

The item returned by this WorldQuery This will be the data retrieved by the query, and is visible to the end user when calling e.g. Query<Self>::get.

fn shrink<'wlong, 'wshort, 's>( item: <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> as QueryData>::Item<'wlong, 's>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> as QueryData>::Item<'wshort, 's>

where 'wlong: 'wshort,

This function manually implements subtyping for the query items.

unsafe fn fetch<'w, 's>( _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> as WorldQuery>::State, _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Option<<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> as QueryData>::Item<'w, 's>>

Fetch Self::Item for either the given entity in the current Table, or for the given entity in the current Archetype. This must always be called after WorldQuery::set_table with a table_row in the range of the current Table or after WorldQuery::set_archetype with an entity in the current archetype. Accesses components registered in WorldQuery::update_component_access.

fn iter_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> as WorldQuery>::State, ) -> impl Iterator<Item = EcsAccessType<'_>>

Returns an iterator over the access needed by QueryData::fetch. Access conflicts are usually checked in WorldQuery::update_component_access, but in certain cases this method can be useful to implement a way of checking for access conflicts in a non-allocating way.

fn provide_extra_access( _state: &mut Self::State, _access: &mut Access, _available_access: &Access, )

Offers additional access above what we requested in update_component_access. Implementations may add additional access that is a subset of available_access and does not conflict with anything in access, and must update access to include that access.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12> QueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)>

where F0: QueryData, F1: QueryData, F2: QueryData, F3: QueryData, F4: QueryData, F5: QueryData, F6: QueryData, F7: QueryData, F8: QueryData, F9: QueryData, F10: QueryData, F11: QueryData, F12: QueryData,

const IS_READ_ONLY: bool

True if this query is read-only and may not perform mutable access.

const IS_ARCHETYPAL: bool

Returns true if (and only if) this query data relies strictly on archetypes to limit which entities are accessed by the Query.

type ReadOnly = AnyOf<(<F0 as QueryData>::ReadOnly, <F1 as QueryData>::ReadOnly, <F2 as QueryData>::ReadOnly, <F3 as QueryData>::ReadOnly, <F4 as QueryData>::ReadOnly, <F5 as QueryData>::ReadOnly, <F6 as QueryData>::ReadOnly, <F7 as QueryData>::ReadOnly, <F8 as QueryData>::ReadOnly, <F9 as QueryData>::ReadOnly, <F10 as QueryData>::ReadOnly, <F11 as QueryData>::ReadOnly, <F12 as QueryData>::ReadOnly)>

The read-only variant of this QueryData, which satisfies the ReadOnlyQueryData trait.

type Item<'w, 's> = (Option<<F0 as QueryData>::Item<'w, 's>>, Option<<F1 as QueryData>::Item<'w, 's>>, Option<<F2 as QueryData>::Item<'w, 's>>, Option<<F3 as QueryData>::Item<'w, 's>>, Option<<F4 as QueryData>::Item<'w, 's>>, Option<<F5 as QueryData>::Item<'w, 's>>, Option<<F6 as QueryData>::Item<'w, 's>>, Option<<F7 as QueryData>::Item<'w, 's>>, Option<<F8 as QueryData>::Item<'w, 's>>, Option<<F9 as QueryData>::Item<'w, 's>>, Option<<F10 as QueryData>::Item<'w, 's>>, Option<<F11 as QueryData>::Item<'w, 's>>, Option<<F12 as QueryData>::Item<'w, 's>>)

The item returned by this WorldQuery This will be the data retrieved by the query, and is visible to the end user when calling e.g. Query<Self>::get.

fn shrink<'wlong, 'wshort, 's>( item: <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> as QueryData>::Item<'wlong, 's>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> as QueryData>::Item<'wshort, 's>

where 'wlong: 'wshort,

This function manually implements subtyping for the query items.

unsafe fn fetch<'w, 's>( _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> as WorldQuery>::State, _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Option<<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> as QueryData>::Item<'w, 's>>

Fetch Self::Item for either the given entity in the current Table, or for the given entity in the current Archetype. This must always be called after WorldQuery::set_table with a table_row in the range of the current Table or after WorldQuery::set_archetype with an entity in the current archetype. Accesses components registered in WorldQuery::update_component_access.

fn iter_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> as WorldQuery>::State, ) -> impl Iterator<Item = EcsAccessType<'_>>

Returns an iterator over the access needed by QueryData::fetch. Access conflicts are usually checked in WorldQuery::update_component_access, but in certain cases this method can be useful to implement a way of checking for access conflicts in a non-allocating way.

fn provide_extra_access( _state: &mut Self::State, _access: &mut Access, _available_access: &Access, )

Offers additional access above what we requested in update_component_access. Implementations may add additional access that is a subset of available_access and does not conflict with anything in access, and must update access to include that access.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13> QueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)>

where F0: QueryData, F1: QueryData, F2: QueryData, F3: QueryData, F4: QueryData, F5: QueryData, F6: QueryData, F7: QueryData, F8: QueryData, F9: QueryData, F10: QueryData, F11: QueryData, F12: QueryData, F13: QueryData,

const IS_READ_ONLY: bool

True if this query is read-only and may not perform mutable access.

const IS_ARCHETYPAL: bool

Returns true if (and only if) this query data relies strictly on archetypes to limit which entities are accessed by the Query.

type ReadOnly = AnyOf<(<F0 as QueryData>::ReadOnly, <F1 as QueryData>::ReadOnly, <F2 as QueryData>::ReadOnly, <F3 as QueryData>::ReadOnly, <F4 as QueryData>::ReadOnly, <F5 as QueryData>::ReadOnly, <F6 as QueryData>::ReadOnly, <F7 as QueryData>::ReadOnly, <F8 as QueryData>::ReadOnly, <F9 as QueryData>::ReadOnly, <F10 as QueryData>::ReadOnly, <F11 as QueryData>::ReadOnly, <F12 as QueryData>::ReadOnly, <F13 as QueryData>::ReadOnly)>

The read-only variant of this QueryData, which satisfies the ReadOnlyQueryData trait.

type Item<'w, 's> = (Option<<F0 as QueryData>::Item<'w, 's>>, Option<<F1 as QueryData>::Item<'w, 's>>, Option<<F2 as QueryData>::Item<'w, 's>>, Option<<F3 as QueryData>::Item<'w, 's>>, Option<<F4 as QueryData>::Item<'w, 's>>, Option<<F5 as QueryData>::Item<'w, 's>>, Option<<F6 as QueryData>::Item<'w, 's>>, Option<<F7 as QueryData>::Item<'w, 's>>, Option<<F8 as QueryData>::Item<'w, 's>>, Option<<F9 as QueryData>::Item<'w, 's>>, Option<<F10 as QueryData>::Item<'w, 's>>, Option<<F11 as QueryData>::Item<'w, 's>>, Option<<F12 as QueryData>::Item<'w, 's>>, Option<<F13 as QueryData>::Item<'w, 's>>)

The item returned by this WorldQuery This will be the data retrieved by the query, and is visible to the end user when calling e.g. Query<Self>::get.

fn shrink<'wlong, 'wshort, 's>( item: <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> as QueryData>::Item<'wlong, 's>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> as QueryData>::Item<'wshort, 's>

where 'wlong: 'wshort,

This function manually implements subtyping for the query items.

unsafe fn fetch<'w, 's>( _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> as WorldQuery>::State, _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Option<<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> as QueryData>::Item<'w, 's>>

Fetch Self::Item for either the given entity in the current Table, or for the given entity in the current Archetype. This must always be called after WorldQuery::set_table with a table_row in the range of the current Table or after WorldQuery::set_archetype with an entity in the current archetype. Accesses components registered in WorldQuery::update_component_access.

fn iter_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> as WorldQuery>::State, ) -> impl Iterator<Item = EcsAccessType<'_>>

Returns an iterator over the access needed by QueryData::fetch. Access conflicts are usually checked in WorldQuery::update_component_access, but in certain cases this method can be useful to implement a way of checking for access conflicts in a non-allocating way.

fn provide_extra_access( _state: &mut Self::State, _access: &mut Access, _available_access: &Access, )

Offers additional access above what we requested in update_component_access. Implementations may add additional access that is a subset of available_access and does not conflict with anything in access, and must update access to include that access.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14> QueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)>

where F0: QueryData, F1: QueryData, F2: QueryData, F3: QueryData, F4: QueryData, F5: QueryData, F6: QueryData, F7: QueryData, F8: QueryData, F9: QueryData, F10: QueryData, F11: QueryData, F12: QueryData, F13: QueryData, F14: QueryData,

const IS_READ_ONLY: bool

True if this query is read-only and may not perform mutable access.

const IS_ARCHETYPAL: bool

Returns true if (and only if) this query data relies strictly on archetypes to limit which entities are accessed by the Query.

type ReadOnly = AnyOf<(<F0 as QueryData>::ReadOnly, <F1 as QueryData>::ReadOnly, <F2 as QueryData>::ReadOnly, <F3 as QueryData>::ReadOnly, <F4 as QueryData>::ReadOnly, <F5 as QueryData>::ReadOnly, <F6 as QueryData>::ReadOnly, <F7 as QueryData>::ReadOnly, <F8 as QueryData>::ReadOnly, <F9 as QueryData>::ReadOnly, <F10 as QueryData>::ReadOnly, <F11 as QueryData>::ReadOnly, <F12 as QueryData>::ReadOnly, <F13 as QueryData>::ReadOnly, <F14 as QueryData>::ReadOnly)>

The read-only variant of this QueryData, which satisfies the ReadOnlyQueryData trait.

type Item<'w, 's> = (Option<<F0 as QueryData>::Item<'w, 's>>, Option<<F1 as QueryData>::Item<'w, 's>>, Option<<F2 as QueryData>::Item<'w, 's>>, Option<<F3 as QueryData>::Item<'w, 's>>, Option<<F4 as QueryData>::Item<'w, 's>>, Option<<F5 as QueryData>::Item<'w, 's>>, Option<<F6 as QueryData>::Item<'w, 's>>, Option<<F7 as QueryData>::Item<'w, 's>>, Option<<F8 as QueryData>::Item<'w, 's>>, Option<<F9 as QueryData>::Item<'w, 's>>, Option<<F10 as QueryData>::Item<'w, 's>>, Option<<F11 as QueryData>::Item<'w, 's>>, Option<<F12 as QueryData>::Item<'w, 's>>, Option<<F13 as QueryData>::Item<'w, 's>>, Option<<F14 as QueryData>::Item<'w, 's>>)

The item returned by this WorldQuery This will be the data retrieved by the query, and is visible to the end user when calling e.g. Query<Self>::get.

fn shrink<'wlong, 'wshort, 's>( item: <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> as QueryData>::Item<'wlong, 's>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> as QueryData>::Item<'wshort, 's>

where 'wlong: 'wshort,

This function manually implements subtyping for the query items.

unsafe fn fetch<'w, 's>( _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> as WorldQuery>::State, _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow, ) -> Option<<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> as QueryData>::Item<'w, 's>>

Fetch Self::Item for either the given entity in the current Table, or for the given entity in the current Archetype. This must always be called after WorldQuery::set_table with a table_row in the range of the current Table or after WorldQuery::set_archetype with an entity in the current archetype. Accesses components registered in WorldQuery::update_component_access.

fn iter_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> as WorldQuery>::State, ) -> impl Iterator<Item = EcsAccessType<'_>>

Returns an iterator over the access needed by QueryData::fetch. Access conflicts are usually checked in WorldQuery::update_component_access, but in certain cases this method can be useful to implement a way of checking for access conflicts in a non-allocating way.

fn provide_extra_access( _state: &mut Self::State, _access: &mut Access, _available_access: &Access, )

Offers additional access above what we requested in update_component_access. Implementations may add additional access that is a subset of available_access and does not conflict with anything in access, and must update access to include that access.

impl ReleaseStateQueryData for AnyOf<()>

fn release_state<'w>( _: <AnyOf<()> as QueryData>::Item<'w, '_>, ) -> <AnyOf<()> as QueryData>::Item<'w, 'static>

Releases the borrow from the query state by converting an item to have a 'static state lifetime.

impl<F> ReleaseStateQueryData for AnyOf<(F,)>

where F: ReleaseStateQueryData,

fn release_state<'w>( _: <AnyOf<(F,)> as QueryData>::Item<'w, '_>, ) -> <AnyOf<(F,)> as QueryData>::Item<'w, 'static>

Releases the borrow from the query state by converting an item to have a 'static state lifetime.

impl<F0, F1> ReleaseStateQueryData for AnyOf<(F0, F1)>

where F0: ReleaseStateQueryData, F1: ReleaseStateQueryData,

fn release_state<'w>( _: <AnyOf<(F0, F1)> as QueryData>::Item<'w, '_>, ) -> <AnyOf<(F0, F1)> as QueryData>::Item<'w, 'static>

Releases the borrow from the query state by converting an item to have a 'static state lifetime.

impl<F0, F1, F2> ReleaseStateQueryData for AnyOf<(F0, F1, F2)>

where F0: ReleaseStateQueryData, F1: ReleaseStateQueryData, F2: ReleaseStateQueryData,

fn release_state<'w>( _: <AnyOf<(F0, F1, F2)> as QueryData>::Item<'w, '_>, ) -> <AnyOf<(F0, F1, F2)> as QueryData>::Item<'w, 'static>

Releases the borrow from the query state by converting an item to have a 'static state lifetime.

impl<F0, F1, F2, F3> ReleaseStateQueryData for AnyOf<(F0, F1, F2, F3)>

where F0: ReleaseStateQueryData, F1: ReleaseStateQueryData, F2: ReleaseStateQueryData, F3: ReleaseStateQueryData,

fn release_state<'w>( _: <AnyOf<(F0, F1, F2, F3)> as QueryData>::Item<'w, '_>, ) -> <AnyOf<(F0, F1, F2, F3)> as QueryData>::Item<'w, 'static>

Releases the borrow from the query state by converting an item to have a 'static state lifetime.

impl<F0, F1, F2, F3, F4> ReleaseStateQueryData for AnyOf<(F0, F1, F2, F3, F4)>

where F0: ReleaseStateQueryData, F1: ReleaseStateQueryData, F2: ReleaseStateQueryData, F3: ReleaseStateQueryData, F4: ReleaseStateQueryData,

fn release_state<'w>( _: <AnyOf<(F0, F1, F2, F3, F4)> as QueryData>::Item<'w, '_>, ) -> <AnyOf<(F0, F1, F2, F3, F4)> as QueryData>::Item<'w, 'static>

Releases the borrow from the query state by converting an item to have a 'static state lifetime.

impl<F0, F1, F2, F3, F4, F5> ReleaseStateQueryData for AnyOf<(F0, F1, F2, F3, F4, F5)>

where F0: ReleaseStateQueryData, F1: ReleaseStateQueryData, F2: ReleaseStateQueryData, F3: ReleaseStateQueryData, F4: ReleaseStateQueryData, F5: ReleaseStateQueryData,

fn release_state<'w>( _: <AnyOf<(F0, F1, F2, F3, F4, F5)> as QueryData>::Item<'w, '_>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5)> as QueryData>::Item<'w, 'static>

Releases the borrow from the query state by converting an item to have a 'static state lifetime.

impl<F0, F1, F2, F3, F4, F5, F6> ReleaseStateQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6)>

where F0: ReleaseStateQueryData, F1: ReleaseStateQueryData, F2: ReleaseStateQueryData, F3: ReleaseStateQueryData, F4: ReleaseStateQueryData, F5: ReleaseStateQueryData, F6: ReleaseStateQueryData,

fn release_state<'w>( _: <AnyOf<(F0, F1, F2, F3, F4, F5, F6)> as QueryData>::Item<'w, '_>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6)> as QueryData>::Item<'w, 'static>

Releases the borrow from the query state by converting an item to have a 'static state lifetime.

impl<F0, F1, F2, F3, F4, F5, F6, F7> ReleaseStateQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)>

where F0: ReleaseStateQueryData, F1: ReleaseStateQueryData, F2: ReleaseStateQueryData, F3: ReleaseStateQueryData, F4: ReleaseStateQueryData, F5: ReleaseStateQueryData, F6: ReleaseStateQueryData, F7: ReleaseStateQueryData,

fn release_state<'w>( _: <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)> as QueryData>::Item<'w, '_>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)> as QueryData>::Item<'w, 'static>

Releases the borrow from the query state by converting an item to have a 'static state lifetime.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8> ReleaseStateQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)>

where F0: ReleaseStateQueryData, F1: ReleaseStateQueryData, F2: ReleaseStateQueryData, F3: ReleaseStateQueryData, F4: ReleaseStateQueryData, F5: ReleaseStateQueryData, F6: ReleaseStateQueryData, F7: ReleaseStateQueryData, F8: ReleaseStateQueryData,

fn release_state<'w>( _: <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> as QueryData>::Item<'w, '_>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> as QueryData>::Item<'w, 'static>

Releases the borrow from the query state by converting an item to have a 'static state lifetime.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> ReleaseStateQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)>

where F0: ReleaseStateQueryData, F1: ReleaseStateQueryData, F2: ReleaseStateQueryData, F3: ReleaseStateQueryData, F4: ReleaseStateQueryData, F5: ReleaseStateQueryData, F6: ReleaseStateQueryData, F7: ReleaseStateQueryData, F8: ReleaseStateQueryData, F9: ReleaseStateQueryData,

fn release_state<'w>( _: <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> as QueryData>::Item<'w, '_>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> as QueryData>::Item<'w, 'static>

Releases the borrow from the query state by converting an item to have a 'static state lifetime.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> ReleaseStateQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)>

where F0: ReleaseStateQueryData, F1: ReleaseStateQueryData, F2: ReleaseStateQueryData, F3: ReleaseStateQueryData, F4: ReleaseStateQueryData, F5: ReleaseStateQueryData, F6: ReleaseStateQueryData, F7: ReleaseStateQueryData, F8: ReleaseStateQueryData, F9: ReleaseStateQueryData, F10: ReleaseStateQueryData,

fn release_state<'w>( _: <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> as QueryData>::Item<'w, '_>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> as QueryData>::Item<'w, 'static>

Releases the borrow from the query state by converting an item to have a 'static state lifetime.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> ReleaseStateQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)>

where F0: ReleaseStateQueryData, F1: ReleaseStateQueryData, F2: ReleaseStateQueryData, F3: ReleaseStateQueryData, F4: ReleaseStateQueryData, F5: ReleaseStateQueryData, F6: ReleaseStateQueryData, F7: ReleaseStateQueryData, F8: ReleaseStateQueryData, F9: ReleaseStateQueryData, F10: ReleaseStateQueryData, F11: ReleaseStateQueryData,

fn release_state<'w>( _: <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> as QueryData>::Item<'w, '_>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> as QueryData>::Item<'w, 'static>

Releases the borrow from the query state by converting an item to have a 'static state lifetime.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12> ReleaseStateQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)>

where F0: ReleaseStateQueryData, F1: ReleaseStateQueryData, F2: ReleaseStateQueryData, F3: ReleaseStateQueryData, F4: ReleaseStateQueryData, F5: ReleaseStateQueryData, F6: ReleaseStateQueryData, F7: ReleaseStateQueryData, F8: ReleaseStateQueryData, F9: ReleaseStateQueryData, F10: ReleaseStateQueryData, F11: ReleaseStateQueryData, F12: ReleaseStateQueryData,

fn release_state<'w>( _: <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> as QueryData>::Item<'w, '_>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> as QueryData>::Item<'w, 'static>

Releases the borrow from the query state by converting an item to have a 'static state lifetime.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13> ReleaseStateQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)>

where F0: ReleaseStateQueryData, F1: ReleaseStateQueryData, F2: ReleaseStateQueryData, F3: ReleaseStateQueryData, F4: ReleaseStateQueryData, F5: ReleaseStateQueryData, F6: ReleaseStateQueryData, F7: ReleaseStateQueryData, F8: ReleaseStateQueryData, F9: ReleaseStateQueryData, F10: ReleaseStateQueryData, F11: ReleaseStateQueryData, F12: ReleaseStateQueryData, F13: ReleaseStateQueryData,

fn release_state<'w>( _: <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> as QueryData>::Item<'w, '_>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> as QueryData>::Item<'w, 'static>

Releases the borrow from the query state by converting an item to have a 'static state lifetime.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14> ReleaseStateQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)>

where F0: ReleaseStateQueryData, F1: ReleaseStateQueryData, F2: ReleaseStateQueryData, F3: ReleaseStateQueryData, F4: ReleaseStateQueryData, F5: ReleaseStateQueryData, F6: ReleaseStateQueryData, F7: ReleaseStateQueryData, F8: ReleaseStateQueryData, F9: ReleaseStateQueryData, F10: ReleaseStateQueryData, F11: ReleaseStateQueryData, F12: ReleaseStateQueryData, F13: ReleaseStateQueryData, F14: ReleaseStateQueryData,

fn release_state<'w>( _: <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> as QueryData>::Item<'w, '_>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> as QueryData>::Item<'w, 'static>

Releases the borrow from the query state by converting an item to have a 'static state lifetime.

impl WorldQuery for AnyOf<()>

const IS_DENSE: bool = true

Returns true if (and only if) every table of every archetype matched by this fetch contains all of the matched components.

type Fetch<'w> = ()

Per archetype/table state retrieved by this WorldQuery to compute Self::Item for each entity.

type State = ()

State used to construct a Self::Fetch. This will be cached inside QueryState, so it is best to move as much data / computation here as possible to reduce the cost of constructing Self::Fetch.

fn shrink_fetch<'wlong, 'wshort>( fetch: <AnyOf<()> as WorldQuery>::Fetch<'wlong>, ) -> <AnyOf<()> as WorldQuery>::Fetch<'wshort>

where 'wlong: 'wshort,

This function manually implements subtyping for the query fetches.

unsafe fn init_fetch<'w, 's>( _world: UnsafeWorldCell<'w>, state: &'s <AnyOf<()> as WorldQuery>::State, _last_run: Tick, _this_run: Tick, ) -> <AnyOf<()> as WorldQuery>::Fetch<'w>

Creates a new instance of Self::Fetch, by combining data from the World with the cached Self::State. Readonly accesses resources registered in WorldQuery::update_component_access.

unsafe fn set_archetype<'w, 's>( _fetch: &mut <AnyOf<()> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<()> as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table, )

Adjusts internal state to account for the next Archetype. This will always be called on archetypes that match this WorldQuery.

unsafe fn set_table<'w, 's>( _fetch: &mut <AnyOf<()> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<()> as WorldQuery>::State, _table: &'w Table, )

Adjusts internal state to account for the next Table. This will always be called on tables that match this WorldQuery.

fn update_component_access( state: &<AnyOf<()> as WorldQuery>::State, access: &mut FilteredAccess, )

Adds any component accesses to the current entity used by this WorldQuery to access.

fn init_nested_access( state: &<AnyOf<()> as WorldQuery>::State, system_name: Option<&str>, component_access_set: &mut FilteredAccessSet, world: UnsafeWorldCell<'_>, )

Adds any component accesses to other entities used by this WorldQuery.

fn init_state(world: &mut World) -> <AnyOf<()> as WorldQuery>::State

Creates and initializes a State for this WorldQuery type.

fn get_state( components: &Components, ) -> Option<<AnyOf<()> as WorldQuery>::State>

Attempts to initialize a State for this WorldQuery type using read-only access to Components.

fn matches_component_set( _state: &<AnyOf<()> as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Returns true if this query matches a set of components. Otherwise, returns false.

fn update_archetypes( state: &mut <AnyOf<()> as WorldQuery>::State, world: UnsafeWorldCell<'_>, )

Called when the query state is updating its archetype cache. This can be used by nested queries to update their internal archetype caches.

impl<F> WorldQuery for AnyOf<(F,)>

where F: WorldQuery,

const IS_DENSE: bool

Returns true if (and only if) every table of every archetype matched by this fetch contains all of the matched components.

type Fetch<'w> = ((<F as WorldQuery>::Fetch<'w>, bool),)

Per archetype/table state retrieved by this WorldQuery to compute Self::Item for each entity.

type State = (<F as WorldQuery>::State,)

State used to construct a Self::Fetch. This will be cached inside QueryState, so it is best to move as much data / computation here as possible to reduce the cost of constructing Self::Fetch.

fn shrink_fetch<'wlong, 'wshort>( fetch: <AnyOf<(F,)> as WorldQuery>::Fetch<'wlong>, ) -> <AnyOf<(F,)> as WorldQuery>::Fetch<'wshort>

where 'wlong: 'wshort,

This function manually implements subtyping for the query fetches.

unsafe fn init_fetch<'w, 's>( _world: UnsafeWorldCell<'w>, state: &'s <AnyOf<(F,)> as WorldQuery>::State, _last_run: Tick, _this_run: Tick, ) -> <AnyOf<(F,)> as WorldQuery>::Fetch<'w>

Creates a new instance of Self::Fetch, by combining data from the World with the cached Self::State. Readonly accesses resources registered in WorldQuery::update_component_access.

unsafe fn set_archetype<'w, 's>( _fetch: &mut <AnyOf<(F,)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F,)> as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table, )

Adjusts internal state to account for the next Archetype. This will always be called on archetypes that match this WorldQuery.

unsafe fn set_table<'w, 's>( _fetch: &mut <AnyOf<(F,)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F,)> as WorldQuery>::State, _table: &'w Table, )

Adjusts internal state to account for the next Table. This will always be called on tables that match this WorldQuery.

fn update_component_access( state: &<AnyOf<(F,)> as WorldQuery>::State, access: &mut FilteredAccess, )

Adds any component accesses to the current entity used by this WorldQuery to access.

fn init_nested_access( state: &<AnyOf<(F,)> as WorldQuery>::State, system_name: Option<&str>, component_access_set: &mut FilteredAccessSet, world: UnsafeWorldCell<'_>, )

Adds any component accesses to other entities used by this WorldQuery.

fn init_state(world: &mut World) -> <AnyOf<(F,)> as WorldQuery>::State

Creates and initializes a State for this WorldQuery type.

fn get_state( components: &Components, ) -> Option<<AnyOf<(F,)> as WorldQuery>::State>

Attempts to initialize a State for this WorldQuery type using read-only access to Components.

fn matches_component_set( _state: &<AnyOf<(F,)> as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Returns true if this query matches a set of components. Otherwise, returns false.

fn update_archetypes( state: &mut <AnyOf<(F,)> as WorldQuery>::State, world: UnsafeWorldCell<'_>, )

Called when the query state is updating its archetype cache. This can be used by nested queries to update their internal archetype caches.

impl<F0, F1> WorldQuery for AnyOf<(F0, F1)>

where F0: WorldQuery, F1: WorldQuery,

const IS_DENSE: bool

Returns true if (and only if) every table of every archetype matched by this fetch contains all of the matched components.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool))

Per archetype/table state retrieved by this WorldQuery to compute Self::Item for each entity.

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State)

State used to construct a Self::Fetch. This will be cached inside QueryState, so it is best to move as much data / computation here as possible to reduce the cost of constructing Self::Fetch.

fn shrink_fetch<'wlong, 'wshort>( fetch: <AnyOf<(F0, F1)> as WorldQuery>::Fetch<'wlong>, ) -> <AnyOf<(F0, F1)> as WorldQuery>::Fetch<'wshort>

where 'wlong: 'wshort,

This function manually implements subtyping for the query fetches.

unsafe fn init_fetch<'w, 's>( _world: UnsafeWorldCell<'w>, state: &'s <AnyOf<(F0, F1)> as WorldQuery>::State, _last_run: Tick, _this_run: Tick, ) -> <AnyOf<(F0, F1)> as WorldQuery>::Fetch<'w>

Creates a new instance of Self::Fetch, by combining data from the World with the cached Self::State. Readonly accesses resources registered in WorldQuery::update_component_access.

unsafe fn set_archetype<'w, 's>( _fetch: &mut <AnyOf<(F0, F1)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1)> as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table, )

Adjusts internal state to account for the next Archetype. This will always be called on archetypes that match this WorldQuery.

unsafe fn set_table<'w, 's>( _fetch: &mut <AnyOf<(F0, F1)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1)> as WorldQuery>::State, _table: &'w Table, )

Adjusts internal state to account for the next Table. This will always be called on tables that match this WorldQuery.

fn update_component_access( state: &<AnyOf<(F0, F1)> as WorldQuery>::State, access: &mut FilteredAccess, )

Adds any component accesses to the current entity used by this WorldQuery to access.

fn init_nested_access( state: &<AnyOf<(F0, F1)> as WorldQuery>::State, system_name: Option<&str>, component_access_set: &mut FilteredAccessSet, world: UnsafeWorldCell<'_>, )

Adds any component accesses to other entities used by this WorldQuery.

fn init_state(world: &mut World) -> <AnyOf<(F0, F1)> as WorldQuery>::State

Creates and initializes a State for this WorldQuery type.

fn get_state( components: &Components, ) -> Option<<AnyOf<(F0, F1)> as WorldQuery>::State>

Attempts to initialize a State for this WorldQuery type using read-only access to Components.

fn matches_component_set( _state: &<AnyOf<(F0, F1)> as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Returns true if this query matches a set of components. Otherwise, returns false.

fn update_archetypes( state: &mut <AnyOf<(F0, F1)> as WorldQuery>::State, world: UnsafeWorldCell<'_>, )

Called when the query state is updating its archetype cache. This can be used by nested queries to update their internal archetype caches.

impl<F0, F1, F2> WorldQuery for AnyOf<(F0, F1, F2)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery,

const IS_DENSE: bool

Returns true if (and only if) every table of every archetype matched by this fetch contains all of the matched components.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool))

Per archetype/table state retrieved by this WorldQuery to compute Self::Item for each entity.

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State)

State used to construct a Self::Fetch. This will be cached inside QueryState, so it is best to move as much data / computation here as possible to reduce the cost of constructing Self::Fetch.

fn shrink_fetch<'wlong, 'wshort>( fetch: <AnyOf<(F0, F1, F2)> as WorldQuery>::Fetch<'wlong>, ) -> <AnyOf<(F0, F1, F2)> as WorldQuery>::Fetch<'wshort>

where 'wlong: 'wshort,

This function manually implements subtyping for the query fetches.

unsafe fn init_fetch<'w, 's>( _world: UnsafeWorldCell<'w>, state: &'s <AnyOf<(F0, F1, F2)> as WorldQuery>::State, _last_run: Tick, _this_run: Tick, ) -> <AnyOf<(F0, F1, F2)> as WorldQuery>::Fetch<'w>

Creates a new instance of Self::Fetch, by combining data from the World with the cached Self::State. Readonly accesses resources registered in WorldQuery::update_component_access.

unsafe fn set_archetype<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2)> as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table, )

Adjusts internal state to account for the next Archetype. This will always be called on archetypes that match this WorldQuery.

unsafe fn set_table<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2)> as WorldQuery>::State, _table: &'w Table, )

Adjusts internal state to account for the next Table. This will always be called on tables that match this WorldQuery.

fn update_component_access( state: &<AnyOf<(F0, F1, F2)> as WorldQuery>::State, access: &mut FilteredAccess, )

Adds any component accesses to the current entity used by this WorldQuery to access.

fn init_nested_access( state: &<AnyOf<(F0, F1, F2)> as WorldQuery>::State, system_name: Option<&str>, component_access_set: &mut FilteredAccessSet, world: UnsafeWorldCell<'_>, )

Adds any component accesses to other entities used by this WorldQuery.

fn init_state(world: &mut World) -> <AnyOf<(F0, F1, F2)> as WorldQuery>::State

Creates and initializes a State for this WorldQuery type.

fn get_state( components: &Components, ) -> Option<<AnyOf<(F0, F1, F2)> as WorldQuery>::State>

Attempts to initialize a State for this WorldQuery type using read-only access to Components.

fn matches_component_set( _state: &<AnyOf<(F0, F1, F2)> as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Returns true if this query matches a set of components. Otherwise, returns false.

fn update_archetypes( state: &mut <AnyOf<(F0, F1, F2)> as WorldQuery>::State, world: UnsafeWorldCell<'_>, )

Called when the query state is updating its archetype cache. This can be used by nested queries to update their internal archetype caches.

impl<F0, F1, F2, F3> WorldQuery for AnyOf<(F0, F1, F2, F3)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery,

const IS_DENSE: bool

Returns true if (and only if) every table of every archetype matched by this fetch contains all of the matched components.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool))

Per archetype/table state retrieved by this WorldQuery to compute Self::Item for each entity.

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State)

State used to construct a Self::Fetch. This will be cached inside QueryState, so it is best to move as much data / computation here as possible to reduce the cost of constructing Self::Fetch.

fn shrink_fetch<'wlong, 'wshort>( fetch: <AnyOf<(F0, F1, F2, F3)> as WorldQuery>::Fetch<'wlong>, ) -> <AnyOf<(F0, F1, F2, F3)> as WorldQuery>::Fetch<'wshort>

where 'wlong: 'wshort,

This function manually implements subtyping for the query fetches.

unsafe fn init_fetch<'w, 's>( _world: UnsafeWorldCell<'w>, state: &'s <AnyOf<(F0, F1, F2, F3)> as WorldQuery>::State, _last_run: Tick, _this_run: Tick, ) -> <AnyOf<(F0, F1, F2, F3)> as WorldQuery>::Fetch<'w>

Creates a new instance of Self::Fetch, by combining data from the World with the cached Self::State. Readonly accesses resources registered in WorldQuery::update_component_access.

unsafe fn set_archetype<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2, F3)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2, F3)> as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table, )

Adjusts internal state to account for the next Archetype. This will always be called on archetypes that match this WorldQuery.

unsafe fn set_table<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2, F3)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2, F3)> as WorldQuery>::State, _table: &'w Table, )

Adjusts internal state to account for the next Table. This will always be called on tables that match this WorldQuery.

fn update_component_access( state: &<AnyOf<(F0, F1, F2, F3)> as WorldQuery>::State, access: &mut FilteredAccess, )

Adds any component accesses to the current entity used by this WorldQuery to access.

fn init_nested_access( state: &<AnyOf<(F0, F1, F2, F3)> as WorldQuery>::State, system_name: Option<&str>, component_access_set: &mut FilteredAccessSet, world: UnsafeWorldCell<'_>, )

Adds any component accesses to other entities used by this WorldQuery.

fn init_state( world: &mut World, ) -> <AnyOf<(F0, F1, F2, F3)> as WorldQuery>::State

Creates and initializes a State for this WorldQuery type.

fn get_state( components: &Components, ) -> Option<<AnyOf<(F0, F1, F2, F3)> as WorldQuery>::State>

Attempts to initialize a State for this WorldQuery type using read-only access to Components.

fn matches_component_set( _state: &<AnyOf<(F0, F1, F2, F3)> as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Returns true if this query matches a set of components. Otherwise, returns false.

fn update_archetypes( state: &mut <AnyOf<(F0, F1, F2, F3)> as WorldQuery>::State, world: UnsafeWorldCell<'_>, )

Called when the query state is updating its archetype cache. This can be used by nested queries to update their internal archetype caches.

impl<F0, F1, F2, F3, F4> WorldQuery for AnyOf<(F0, F1, F2, F3, F4)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery,

const IS_DENSE: bool

Returns true if (and only if) every table of every archetype matched by this fetch contains all of the matched components.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool))

Per archetype/table state retrieved by this WorldQuery to compute Self::Item for each entity.

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State)

State used to construct a Self::Fetch. This will be cached inside QueryState, so it is best to move as much data / computation here as possible to reduce the cost of constructing Self::Fetch.

fn shrink_fetch<'wlong, 'wshort>( fetch: <AnyOf<(F0, F1, F2, F3, F4)> as WorldQuery>::Fetch<'wlong>, ) -> <AnyOf<(F0, F1, F2, F3, F4)> as WorldQuery>::Fetch<'wshort>

where 'wlong: 'wshort,

This function manually implements subtyping for the query fetches.

unsafe fn init_fetch<'w, 's>( _world: UnsafeWorldCell<'w>, state: &'s <AnyOf<(F0, F1, F2, F3, F4)> as WorldQuery>::State, _last_run: Tick, _this_run: Tick, ) -> <AnyOf<(F0, F1, F2, F3, F4)> as WorldQuery>::Fetch<'w>

Creates a new instance of Self::Fetch, by combining data from the World with the cached Self::State. Readonly accesses resources registered in WorldQuery::update_component_access.

unsafe fn set_archetype<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2, F3, F4)> as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table, )

Adjusts internal state to account for the next Archetype. This will always be called on archetypes that match this WorldQuery.

unsafe fn set_table<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2, F3, F4)> as WorldQuery>::State, _table: &'w Table, )

Adjusts internal state to account for the next Table. This will always be called on tables that match this WorldQuery.

fn update_component_access( state: &<AnyOf<(F0, F1, F2, F3, F4)> as WorldQuery>::State, access: &mut FilteredAccess, )

Adds any component accesses to the current entity used by this WorldQuery to access.

fn init_nested_access( state: &<AnyOf<(F0, F1, F2, F3, F4)> as WorldQuery>::State, system_name: Option<&str>, component_access_set: &mut FilteredAccessSet, world: UnsafeWorldCell<'_>, )

Adds any component accesses to other entities used by this WorldQuery.

fn init_state( world: &mut World, ) -> <AnyOf<(F0, F1, F2, F3, F4)> as WorldQuery>::State

Creates and initializes a State for this WorldQuery type.

fn get_state( components: &Components, ) -> Option<<AnyOf<(F0, F1, F2, F3, F4)> as WorldQuery>::State>

Attempts to initialize a State for this WorldQuery type using read-only access to Components.

fn matches_component_set( _state: &<AnyOf<(F0, F1, F2, F3, F4)> as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Returns true if this query matches a set of components. Otherwise, returns false.

fn update_archetypes( state: &mut <AnyOf<(F0, F1, F2, F3, F4)> as WorldQuery>::State, world: UnsafeWorldCell<'_>, )

Called when the query state is updating its archetype cache. This can be used by nested queries to update their internal archetype caches.

impl<F0, F1, F2, F3, F4, F5> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery,

const IS_DENSE: bool

Returns true if (and only if) every table of every archetype matched by this fetch contains all of the matched components.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool))

Per archetype/table state retrieved by this WorldQuery to compute Self::Item for each entity.

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State)

State used to construct a Self::Fetch. This will be cached inside QueryState, so it is best to move as much data / computation here as possible to reduce the cost of constructing Self::Fetch.

fn shrink_fetch<'wlong, 'wshort>( fetch: <AnyOf<(F0, F1, F2, F3, F4, F5)> as WorldQuery>::Fetch<'wlong>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5)> as WorldQuery>::Fetch<'wshort>

where 'wlong: 'wshort,

This function manually implements subtyping for the query fetches.

unsafe fn init_fetch<'w, 's>( _world: UnsafeWorldCell<'w>, state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5)> as WorldQuery>::State, _last_run: Tick, _this_run: Tick, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5)> as WorldQuery>::Fetch<'w>

Creates a new instance of Self::Fetch, by combining data from the World with the cached Self::State. Readonly accesses resources registered in WorldQuery::update_component_access.

unsafe fn set_archetype<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5)> as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table, )

Adjusts internal state to account for the next Archetype. This will always be called on archetypes that match this WorldQuery.

unsafe fn set_table<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5)> as WorldQuery>::State, _table: &'w Table, )

Adjusts internal state to account for the next Table. This will always be called on tables that match this WorldQuery.

fn update_component_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5)> as WorldQuery>::State, access: &mut FilteredAccess, )

Adds any component accesses to the current entity used by this WorldQuery to access.

fn init_nested_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5)> as WorldQuery>::State, system_name: Option<&str>, component_access_set: &mut FilteredAccessSet, world: UnsafeWorldCell<'_>, )

Adds any component accesses to other entities used by this WorldQuery.

fn init_state( world: &mut World, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5)> as WorldQuery>::State

Creates and initializes a State for this WorldQuery type.

fn get_state( components: &Components, ) -> Option<<AnyOf<(F0, F1, F2, F3, F4, F5)> as WorldQuery>::State>

Attempts to initialize a State for this WorldQuery type using read-only access to Components.

fn matches_component_set( _state: &<AnyOf<(F0, F1, F2, F3, F4, F5)> as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Returns true if this query matches a set of components. Otherwise, returns false.

fn update_archetypes( state: &mut <AnyOf<(F0, F1, F2, F3, F4, F5)> as WorldQuery>::State, world: UnsafeWorldCell<'_>, )

Called when the query state is updating its archetype cache. This can be used by nested queries to update their internal archetype caches.

impl<F0, F1, F2, F3, F4, F5, F6> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery,

const IS_DENSE: bool

Returns true if (and only if) every table of every archetype matched by this fetch contains all of the matched components.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool))

Per archetype/table state retrieved by this WorldQuery to compute Self::Item for each entity.

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State)

State used to construct a Self::Fetch. This will be cached inside QueryState, so it is best to move as much data / computation here as possible to reduce the cost of constructing Self::Fetch.

fn shrink_fetch<'wlong, 'wshort>( fetch: <AnyOf<(F0, F1, F2, F3, F4, F5, F6)> as WorldQuery>::Fetch<'wlong>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6)> as WorldQuery>::Fetch<'wshort>

where 'wlong: 'wshort,

This function manually implements subtyping for the query fetches.

unsafe fn init_fetch<'w, 's>( _world: UnsafeWorldCell<'w>, state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6)> as WorldQuery>::State, _last_run: Tick, _this_run: Tick, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6)> as WorldQuery>::Fetch<'w>

Creates a new instance of Self::Fetch, by combining data from the World with the cached Self::State. Readonly accesses resources registered in WorldQuery::update_component_access.

unsafe fn set_archetype<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6)> as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table, )

Adjusts internal state to account for the next Archetype. This will always be called on archetypes that match this WorldQuery.

unsafe fn set_table<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6)> as WorldQuery>::State, _table: &'w Table, )

Adjusts internal state to account for the next Table. This will always be called on tables that match this WorldQuery.

fn update_component_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6)> as WorldQuery>::State, access: &mut FilteredAccess, )

Adds any component accesses to the current entity used by this WorldQuery to access.

fn init_nested_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6)> as WorldQuery>::State, system_name: Option<&str>, component_access_set: &mut FilteredAccessSet, world: UnsafeWorldCell<'_>, )

Adds any component accesses to other entities used by this WorldQuery.

fn init_state( world: &mut World, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6)> as WorldQuery>::State

Creates and initializes a State for this WorldQuery type.

fn get_state( components: &Components, ) -> Option<<AnyOf<(F0, F1, F2, F3, F4, F5, F6)> as WorldQuery>::State>

Attempts to initialize a State for this WorldQuery type using read-only access to Components.

fn matches_component_set( _state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6)> as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Returns true if this query matches a set of components. Otherwise, returns false.

fn update_archetypes( state: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6)> as WorldQuery>::State, world: UnsafeWorldCell<'_>, )

Called when the query state is updating its archetype cache. This can be used by nested queries to update their internal archetype caches.

impl<F0, F1, F2, F3, F4, F5, F6, F7> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery,

const IS_DENSE: bool

Returns true if (and only if) every table of every archetype matched by this fetch contains all of the matched components.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool), (<F7 as WorldQuery>::Fetch<'w>, bool))

Per archetype/table state retrieved by this WorldQuery to compute Self::Item for each entity.

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State)

State used to construct a Self::Fetch. This will be cached inside QueryState, so it is best to move as much data / computation here as possible to reduce the cost of constructing Self::Fetch.

fn shrink_fetch<'wlong, 'wshort>( fetch: <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)> as WorldQuery>::Fetch<'wlong>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)> as WorldQuery>::Fetch<'wshort>

where 'wlong: 'wshort,

This function manually implements subtyping for the query fetches.

unsafe fn init_fetch<'w, 's>( _world: UnsafeWorldCell<'w>, state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)> as WorldQuery>::State, _last_run: Tick, _this_run: Tick, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)> as WorldQuery>::Fetch<'w>

Creates a new instance of Self::Fetch, by combining data from the World with the cached Self::State. Readonly accesses resources registered in WorldQuery::update_component_access.

unsafe fn set_archetype<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)> as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table, )

Adjusts internal state to account for the next Archetype. This will always be called on archetypes that match this WorldQuery.

unsafe fn set_table<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)> as WorldQuery>::State, _table: &'w Table, )

Adjusts internal state to account for the next Table. This will always be called on tables that match this WorldQuery.

fn update_component_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)> as WorldQuery>::State, access: &mut FilteredAccess, )

Adds any component accesses to the current entity used by this WorldQuery to access.

fn init_nested_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)> as WorldQuery>::State, system_name: Option<&str>, component_access_set: &mut FilteredAccessSet, world: UnsafeWorldCell<'_>, )

Adds any component accesses to other entities used by this WorldQuery.

fn init_state( world: &mut World, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)> as WorldQuery>::State

Creates and initializes a State for this WorldQuery type.

fn get_state( components: &Components, ) -> Option<<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)> as WorldQuery>::State>

Attempts to initialize a State for this WorldQuery type using read-only access to Components.

fn matches_component_set( _state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)> as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Returns true if this query matches a set of components. Otherwise, returns false.

fn update_archetypes( state: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)> as WorldQuery>::State, world: UnsafeWorldCell<'_>, )

Called when the query state is updating its archetype cache. This can be used by nested queries to update their internal archetype caches.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery,

const IS_DENSE: bool

Returns true if (and only if) every table of every archetype matched by this fetch contains all of the matched components.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool), (<F7 as WorldQuery>::Fetch<'w>, bool), (<F8 as WorldQuery>::Fetch<'w>, bool))

Per archetype/table state retrieved by this WorldQuery to compute Self::Item for each entity.

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State)

State used to construct a Self::Fetch. This will be cached inside QueryState, so it is best to move as much data / computation here as possible to reduce the cost of constructing Self::Fetch.

fn shrink_fetch<'wlong, 'wshort>( fetch: <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> as WorldQuery>::Fetch<'wlong>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> as WorldQuery>::Fetch<'wshort>

where 'wlong: 'wshort,

This function manually implements subtyping for the query fetches.

unsafe fn init_fetch<'w, 's>( _world: UnsafeWorldCell<'w>, state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> as WorldQuery>::State, _last_run: Tick, _this_run: Tick, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> as WorldQuery>::Fetch<'w>

Creates a new instance of Self::Fetch, by combining data from the World with the cached Self::State. Readonly accesses resources registered in WorldQuery::update_component_access.

unsafe fn set_archetype<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table, )

Adjusts internal state to account for the next Archetype. This will always be called on archetypes that match this WorldQuery.

unsafe fn set_table<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> as WorldQuery>::State, _table: &'w Table, )

Adjusts internal state to account for the next Table. This will always be called on tables that match this WorldQuery.

fn update_component_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> as WorldQuery>::State, access: &mut FilteredAccess, )

Adds any component accesses to the current entity used by this WorldQuery to access.

fn init_nested_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> as WorldQuery>::State, system_name: Option<&str>, component_access_set: &mut FilteredAccessSet, world: UnsafeWorldCell<'_>, )

Adds any component accesses to other entities used by this WorldQuery.

fn init_state( world: &mut World, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> as WorldQuery>::State

Creates and initializes a State for this WorldQuery type.

fn get_state( components: &Components, ) -> Option<<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> as WorldQuery>::State>

Attempts to initialize a State for this WorldQuery type using read-only access to Components.

fn matches_component_set( _state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Returns true if this query matches a set of components. Otherwise, returns false.

fn update_archetypes( state: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> as WorldQuery>::State, world: UnsafeWorldCell<'_>, )

Called when the query state is updating its archetype cache. This can be used by nested queries to update their internal archetype caches.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery,

const IS_DENSE: bool

Returns true if (and only if) every table of every archetype matched by this fetch contains all of the matched components.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool), (<F7 as WorldQuery>::Fetch<'w>, bool), (<F8 as WorldQuery>::Fetch<'w>, bool), (<F9 as WorldQuery>::Fetch<'w>, bool))

Per archetype/table state retrieved by this WorldQuery to compute Self::Item for each entity.

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State)

State used to construct a Self::Fetch. This will be cached inside QueryState, so it is best to move as much data / computation here as possible to reduce the cost of constructing Self::Fetch.

fn shrink_fetch<'wlong, 'wshort>( fetch: <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> as WorldQuery>::Fetch<'wlong>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> as WorldQuery>::Fetch<'wshort>

where 'wlong: 'wshort,

This function manually implements subtyping for the query fetches.

unsafe fn init_fetch<'w, 's>( _world: UnsafeWorldCell<'w>, state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> as WorldQuery>::State, _last_run: Tick, _this_run: Tick, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> as WorldQuery>::Fetch<'w>

Creates a new instance of Self::Fetch, by combining data from the World with the cached Self::State. Readonly accesses resources registered in WorldQuery::update_component_access.

unsafe fn set_archetype<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table, )

Adjusts internal state to account for the next Archetype. This will always be called on archetypes that match this WorldQuery.

unsafe fn set_table<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> as WorldQuery>::State, _table: &'w Table, )

Adjusts internal state to account for the next Table. This will always be called on tables that match this WorldQuery.

fn update_component_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> as WorldQuery>::State, access: &mut FilteredAccess, )

Adds any component accesses to the current entity used by this WorldQuery to access.

fn init_nested_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> as WorldQuery>::State, system_name: Option<&str>, component_access_set: &mut FilteredAccessSet, world: UnsafeWorldCell<'_>, )

Adds any component accesses to other entities used by this WorldQuery.

fn init_state( world: &mut World, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> as WorldQuery>::State

Creates and initializes a State for this WorldQuery type.

fn get_state( components: &Components, ) -> Option<<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> as WorldQuery>::State>

Attempts to initialize a State for this WorldQuery type using read-only access to Components.

fn matches_component_set( _state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Returns true if this query matches a set of components. Otherwise, returns false.

fn update_archetypes( state: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> as WorldQuery>::State, world: UnsafeWorldCell<'_>, )

Called when the query state is updating its archetype cache. This can be used by nested queries to update their internal archetype caches.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery,

const IS_DENSE: bool

Returns true if (and only if) every table of every archetype matched by this fetch contains all of the matched components.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool), (<F7 as WorldQuery>::Fetch<'w>, bool), (<F8 as WorldQuery>::Fetch<'w>, bool), (<F9 as WorldQuery>::Fetch<'w>, bool), (<F10 as WorldQuery>::Fetch<'w>, bool))

Per archetype/table state retrieved by this WorldQuery to compute Self::Item for each entity.

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State)

State used to construct a Self::Fetch. This will be cached inside QueryState, so it is best to move as much data / computation here as possible to reduce the cost of constructing Self::Fetch.

fn shrink_fetch<'wlong, 'wshort>( fetch: <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> as WorldQuery>::Fetch<'wlong>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> as WorldQuery>::Fetch<'wshort>

where 'wlong: 'wshort,

This function manually implements subtyping for the query fetches.

unsafe fn init_fetch<'w, 's>( _world: UnsafeWorldCell<'w>, state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> as WorldQuery>::State, _last_run: Tick, _this_run: Tick, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> as WorldQuery>::Fetch<'w>

Creates a new instance of Self::Fetch, by combining data from the World with the cached Self::State. Readonly accesses resources registered in WorldQuery::update_component_access.

unsafe fn set_archetype<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table, )

Adjusts internal state to account for the next Archetype. This will always be called on archetypes that match this WorldQuery.

unsafe fn set_table<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> as WorldQuery>::State, _table: &'w Table, )

Adjusts internal state to account for the next Table. This will always be called on tables that match this WorldQuery.

fn update_component_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> as WorldQuery>::State, access: &mut FilteredAccess, )

Adds any component accesses to the current entity used by this WorldQuery to access.

fn init_nested_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> as WorldQuery>::State, system_name: Option<&str>, component_access_set: &mut FilteredAccessSet, world: UnsafeWorldCell<'_>, )

Adds any component accesses to other entities used by this WorldQuery.

fn init_state( world: &mut World, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> as WorldQuery>::State

Creates and initializes a State for this WorldQuery type.

fn get_state( components: &Components, ) -> Option<<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> as WorldQuery>::State>

Attempts to initialize a State for this WorldQuery type using read-only access to Components.

fn matches_component_set( _state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Returns true if this query matches a set of components. Otherwise, returns false.

fn update_archetypes( state: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> as WorldQuery>::State, world: UnsafeWorldCell<'_>, )

Called when the query state is updating its archetype cache. This can be used by nested queries to update their internal archetype caches.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery, F11: WorldQuery,

const IS_DENSE: bool

Returns true if (and only if) every table of every archetype matched by this fetch contains all of the matched components.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool), (<F7 as WorldQuery>::Fetch<'w>, bool), (<F8 as WorldQuery>::Fetch<'w>, bool), (<F9 as WorldQuery>::Fetch<'w>, bool), (<F10 as WorldQuery>::Fetch<'w>, bool), (<F11 as WorldQuery>::Fetch<'w>, bool))

Per archetype/table state retrieved by this WorldQuery to compute Self::Item for each entity.

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State)

State used to construct a Self::Fetch. This will be cached inside QueryState, so it is best to move as much data / computation here as possible to reduce the cost of constructing Self::Fetch.

fn shrink_fetch<'wlong, 'wshort>( fetch: <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> as WorldQuery>::Fetch<'wlong>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> as WorldQuery>::Fetch<'wshort>

where 'wlong: 'wshort,

This function manually implements subtyping for the query fetches.

unsafe fn init_fetch<'w, 's>( _world: UnsafeWorldCell<'w>, state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> as WorldQuery>::State, _last_run: Tick, _this_run: Tick, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> as WorldQuery>::Fetch<'w>

Creates a new instance of Self::Fetch, by combining data from the World with the cached Self::State. Readonly accesses resources registered in WorldQuery::update_component_access.

unsafe fn set_archetype<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table, )

Adjusts internal state to account for the next Archetype. This will always be called on archetypes that match this WorldQuery.

unsafe fn set_table<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> as WorldQuery>::State, _table: &'w Table, )

Adjusts internal state to account for the next Table. This will always be called on tables that match this WorldQuery.

fn update_component_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> as WorldQuery>::State, access: &mut FilteredAccess, )

Adds any component accesses to the current entity used by this WorldQuery to access.

fn init_nested_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> as WorldQuery>::State, system_name: Option<&str>, component_access_set: &mut FilteredAccessSet, world: UnsafeWorldCell<'_>, )

Adds any component accesses to other entities used by this WorldQuery.

fn init_state( world: &mut World, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> as WorldQuery>::State

Creates and initializes a State for this WorldQuery type.

fn get_state( components: &Components, ) -> Option<<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> as WorldQuery>::State>

Attempts to initialize a State for this WorldQuery type using read-only access to Components.

fn matches_component_set( _state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Returns true if this query matches a set of components. Otherwise, returns false.

fn update_archetypes( state: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> as WorldQuery>::State, world: UnsafeWorldCell<'_>, )

Called when the query state is updating its archetype cache. This can be used by nested queries to update their internal archetype caches.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery, F11: WorldQuery, F12: WorldQuery,

const IS_DENSE: bool

Returns true if (and only if) every table of every archetype matched by this fetch contains all of the matched components.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool), (<F7 as WorldQuery>::Fetch<'w>, bool), (<F8 as WorldQuery>::Fetch<'w>, bool), (<F9 as WorldQuery>::Fetch<'w>, bool), (<F10 as WorldQuery>::Fetch<'w>, bool), (<F11 as WorldQuery>::Fetch<'w>, bool), (<F12 as WorldQuery>::Fetch<'w>, bool))

Per archetype/table state retrieved by this WorldQuery to compute Self::Item for each entity.

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State, <F12 as WorldQuery>::State)

State used to construct a Self::Fetch. This will be cached inside QueryState, so it is best to move as much data / computation here as possible to reduce the cost of constructing Self::Fetch.

fn shrink_fetch<'wlong, 'wshort>( fetch: <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> as WorldQuery>::Fetch<'wlong>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> as WorldQuery>::Fetch<'wshort>

where 'wlong: 'wshort,

This function manually implements subtyping for the query fetches.

unsafe fn init_fetch<'w, 's>( _world: UnsafeWorldCell<'w>, state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> as WorldQuery>::State, _last_run: Tick, _this_run: Tick, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> as WorldQuery>::Fetch<'w>

Creates a new instance of Self::Fetch, by combining data from the World with the cached Self::State. Readonly accesses resources registered in WorldQuery::update_component_access.

unsafe fn set_archetype<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table, )

Adjusts internal state to account for the next Archetype. This will always be called on archetypes that match this WorldQuery.

unsafe fn set_table<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> as WorldQuery>::State, _table: &'w Table, )

Adjusts internal state to account for the next Table. This will always be called on tables that match this WorldQuery.

fn update_component_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> as WorldQuery>::State, access: &mut FilteredAccess, )

Adds any component accesses to the current entity used by this WorldQuery to access.

fn init_nested_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> as WorldQuery>::State, system_name: Option<&str>, component_access_set: &mut FilteredAccessSet, world: UnsafeWorldCell<'_>, )

Adds any component accesses to other entities used by this WorldQuery.

fn init_state( world: &mut World, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> as WorldQuery>::State

Creates and initializes a State for this WorldQuery type.

fn get_state( components: &Components, ) -> Option<<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> as WorldQuery>::State>

Attempts to initialize a State for this WorldQuery type using read-only access to Components.

fn matches_component_set( _state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Returns true if this query matches a set of components. Otherwise, returns false.

fn update_archetypes( state: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> as WorldQuery>::State, world: UnsafeWorldCell<'_>, )

Called when the query state is updating its archetype cache. This can be used by nested queries to update their internal archetype caches.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery, F11: WorldQuery, F12: WorldQuery, F13: WorldQuery,

const IS_DENSE: bool

Returns true if (and only if) every table of every archetype matched by this fetch contains all of the matched components.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool), (<F7 as WorldQuery>::Fetch<'w>, bool), (<F8 as WorldQuery>::Fetch<'w>, bool), (<F9 as WorldQuery>::Fetch<'w>, bool), (<F10 as WorldQuery>::Fetch<'w>, bool), (<F11 as WorldQuery>::Fetch<'w>, bool), (<F12 as WorldQuery>::Fetch<'w>, bool), (<F13 as WorldQuery>::Fetch<'w>, bool))

Per archetype/table state retrieved by this WorldQuery to compute Self::Item for each entity.

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State, <F12 as WorldQuery>::State, <F13 as WorldQuery>::State)

State used to construct a Self::Fetch. This will be cached inside QueryState, so it is best to move as much data / computation here as possible to reduce the cost of constructing Self::Fetch.

fn shrink_fetch<'wlong, 'wshort>( fetch: <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> as WorldQuery>::Fetch<'wlong>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> as WorldQuery>::Fetch<'wshort>

where 'wlong: 'wshort,

This function manually implements subtyping for the query fetches.

unsafe fn init_fetch<'w, 's>( _world: UnsafeWorldCell<'w>, state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> as WorldQuery>::State, _last_run: Tick, _this_run: Tick, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> as WorldQuery>::Fetch<'w>

Creates a new instance of Self::Fetch, by combining data from the World with the cached Self::State. Readonly accesses resources registered in WorldQuery::update_component_access.

unsafe fn set_archetype<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table, )

Adjusts internal state to account for the next Archetype. This will always be called on archetypes that match this WorldQuery.

unsafe fn set_table<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> as WorldQuery>::State, _table: &'w Table, )

Adjusts internal state to account for the next Table. This will always be called on tables that match this WorldQuery.

fn update_component_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> as WorldQuery>::State, access: &mut FilteredAccess, )

Adds any component accesses to the current entity used by this WorldQuery to access.

fn init_nested_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> as WorldQuery>::State, system_name: Option<&str>, component_access_set: &mut FilteredAccessSet, world: UnsafeWorldCell<'_>, )

Adds any component accesses to other entities used by this WorldQuery.

fn init_state( world: &mut World, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> as WorldQuery>::State

Creates and initializes a State for this WorldQuery type.

fn get_state( components: &Components, ) -> Option<<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> as WorldQuery>::State>

Attempts to initialize a State for this WorldQuery type using read-only access to Components.

fn matches_component_set( _state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Returns true if this query matches a set of components. Otherwise, returns false.

fn update_archetypes( state: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> as WorldQuery>::State, world: UnsafeWorldCell<'_>, )

Called when the query state is updating its archetype cache. This can be used by nested queries to update their internal archetype caches.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery, F11: WorldQuery, F12: WorldQuery, F13: WorldQuery, F14: WorldQuery,

const IS_DENSE: bool

Returns true if (and only if) every table of every archetype matched by this fetch contains all of the matched components.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool), (<F7 as WorldQuery>::Fetch<'w>, bool), (<F8 as WorldQuery>::Fetch<'w>, bool), (<F9 as WorldQuery>::Fetch<'w>, bool), (<F10 as WorldQuery>::Fetch<'w>, bool), (<F11 as WorldQuery>::Fetch<'w>, bool), (<F12 as WorldQuery>::Fetch<'w>, bool), (<F13 as WorldQuery>::Fetch<'w>, bool), (<F14 as WorldQuery>::Fetch<'w>, bool))

Per archetype/table state retrieved by this WorldQuery to compute Self::Item for each entity.

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State, <F12 as WorldQuery>::State, <F13 as WorldQuery>::State, <F14 as WorldQuery>::State)

State used to construct a Self::Fetch. This will be cached inside QueryState, so it is best to move as much data / computation here as possible to reduce the cost of constructing Self::Fetch.

fn shrink_fetch<'wlong, 'wshort>( fetch: <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> as WorldQuery>::Fetch<'wlong>, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> as WorldQuery>::Fetch<'wshort>

where 'wlong: 'wshort,

This function manually implements subtyping for the query fetches.

unsafe fn init_fetch<'w, 's>( _world: UnsafeWorldCell<'w>, state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> as WorldQuery>::State, _last_run: Tick, _this_run: Tick, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> as WorldQuery>::Fetch<'w>

Creates a new instance of Self::Fetch, by combining data from the World with the cached Self::State. Readonly accesses resources registered in WorldQuery::update_component_access.

unsafe fn set_archetype<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table, )

Adjusts internal state to account for the next Archetype. This will always be called on archetypes that match this WorldQuery.

unsafe fn set_table<'w, 's>( _fetch: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> as WorldQuery>::Fetch<'w>, _state: &'s <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> as WorldQuery>::State, _table: &'w Table, )

Adjusts internal state to account for the next Table. This will always be called on tables that match this WorldQuery.

fn update_component_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> as WorldQuery>::State, access: &mut FilteredAccess, )

Adds any component accesses to the current entity used by this WorldQuery to access.

fn init_nested_access( state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> as WorldQuery>::State, system_name: Option<&str>, component_access_set: &mut FilteredAccessSet, world: UnsafeWorldCell<'_>, )

Adds any component accesses to other entities used by this WorldQuery.

fn init_state( world: &mut World, ) -> <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> as WorldQuery>::State

Creates and initializes a State for this WorldQuery type.

fn get_state( components: &Components, ) -> Option<<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> as WorldQuery>::State>

Attempts to initialize a State for this WorldQuery type using read-only access to Components.

fn matches_component_set( _state: &<AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

Returns true if this query matches a set of components. Otherwise, returns false.

fn update_archetypes( state: &mut <AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> as WorldQuery>::State, world: UnsafeWorldCell<'_>, )

Called when the query state is updating its archetype cache. This can be used by nested queries to update their internal archetype caches.

impl ArchetypeQueryData for AnyOf<()>

impl<F> ArchetypeQueryData for AnyOf<(F,)>

where F: ArchetypeQueryData,

impl<F0, F1> ArchetypeQueryData for AnyOf<(F0, F1)>

where F0: ArchetypeQueryData, F1: ArchetypeQueryData,

impl<F0, F1, F2> ArchetypeQueryData for AnyOf<(F0, F1, F2)>

where F0: ArchetypeQueryData, F1: ArchetypeQueryData, F2: ArchetypeQueryData,

impl<F0, F1, F2, F3> ArchetypeQueryData for AnyOf<(F0, F1, F2, F3)>

where F0: ArchetypeQueryData, F1: ArchetypeQueryData, F2: ArchetypeQueryData, F3: ArchetypeQueryData,

impl<F0, F1, F2, F3, F4> ArchetypeQueryData for AnyOf<(F0, F1, F2, F3, F4)>

where F0: ArchetypeQueryData, F1: ArchetypeQueryData, F2: ArchetypeQueryData, F3: ArchetypeQueryData, F4: ArchetypeQueryData,

impl<F0, F1, F2, F3, F4, F5> ArchetypeQueryData for AnyOf<(F0, F1, F2, F3, F4, F5)>

where F0: ArchetypeQueryData, F1: ArchetypeQueryData, F2: ArchetypeQueryData, F3: ArchetypeQueryData, F4: ArchetypeQueryData, F5: ArchetypeQueryData,

impl<F0, F1, F2, F3, F4, F5, F6> ArchetypeQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6)>

where F0: ArchetypeQueryData, F1: ArchetypeQueryData, F2: ArchetypeQueryData, F3: ArchetypeQueryData, F4: ArchetypeQueryData, F5: ArchetypeQueryData, F6: ArchetypeQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7> ArchetypeQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)>

where F0: ArchetypeQueryData, F1: ArchetypeQueryData, F2: ArchetypeQueryData, F3: ArchetypeQueryData, F4: ArchetypeQueryData, F5: ArchetypeQueryData, F6: ArchetypeQueryData, F7: ArchetypeQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8> ArchetypeQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)>

where F0: ArchetypeQueryData, F1: ArchetypeQueryData, F2: ArchetypeQueryData, F3: ArchetypeQueryData, F4: ArchetypeQueryData, F5: ArchetypeQueryData, F6: ArchetypeQueryData, F7: ArchetypeQueryData, F8: ArchetypeQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> ArchetypeQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)>

where F0: ArchetypeQueryData, F1: ArchetypeQueryData, F2: ArchetypeQueryData, F3: ArchetypeQueryData, F4: ArchetypeQueryData, F5: ArchetypeQueryData, F6: ArchetypeQueryData, F7: ArchetypeQueryData, F8: ArchetypeQueryData, F9: ArchetypeQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> ArchetypeQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)>

where F0: ArchetypeQueryData, F1: ArchetypeQueryData, F2: ArchetypeQueryData, F3: ArchetypeQueryData, F4: ArchetypeQueryData, F5: ArchetypeQueryData, F6: ArchetypeQueryData, F7: ArchetypeQueryData, F8: ArchetypeQueryData, F9: ArchetypeQueryData, F10: ArchetypeQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> ArchetypeQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)>

where F0: ArchetypeQueryData, F1: ArchetypeQueryData, F2: ArchetypeQueryData, F3: ArchetypeQueryData, F4: ArchetypeQueryData, F5: ArchetypeQueryData, F6: ArchetypeQueryData, F7: ArchetypeQueryData, F8: ArchetypeQueryData, F9: ArchetypeQueryData, F10: ArchetypeQueryData, F11: ArchetypeQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12> ArchetypeQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)>

where F0: ArchetypeQueryData, F1: ArchetypeQueryData, F2: ArchetypeQueryData, F3: ArchetypeQueryData, F4: ArchetypeQueryData, F5: ArchetypeQueryData, F6: ArchetypeQueryData, F7: ArchetypeQueryData, F8: ArchetypeQueryData, F9: ArchetypeQueryData, F10: ArchetypeQueryData, F11: ArchetypeQueryData, F12: ArchetypeQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13> ArchetypeQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)>

where F0: ArchetypeQueryData, F1: ArchetypeQueryData, F2: ArchetypeQueryData, F3: ArchetypeQueryData, F4: ArchetypeQueryData, F5: ArchetypeQueryData, F6: ArchetypeQueryData, F7: ArchetypeQueryData, F8: ArchetypeQueryData, F9: ArchetypeQueryData, F10: ArchetypeQueryData, F11: ArchetypeQueryData, F12: ArchetypeQueryData, F13: ArchetypeQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14> ArchetypeQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)>

where F0: ArchetypeQueryData, F1: ArchetypeQueryData, F2: ArchetypeQueryData, F3: ArchetypeQueryData, F4: ArchetypeQueryData, F5: ArchetypeQueryData, F6: ArchetypeQueryData, F7: ArchetypeQueryData, F8: ArchetypeQueryData, F9: ArchetypeQueryData, F10: ArchetypeQueryData, F11: ArchetypeQueryData, F12: ArchetypeQueryData, F13: ArchetypeQueryData, F14: ArchetypeQueryData,

impl IterQueryData for AnyOf<()>

impl<F> IterQueryData for AnyOf<(F,)>

where F: IterQueryData,

impl<F0, F1> IterQueryData for AnyOf<(F0, F1)>

where F0: IterQueryData, F1: IterQueryData,

impl<F0, F1, F2> IterQueryData for AnyOf<(F0, F1, F2)>

where F0: IterQueryData, F1: IterQueryData, F2: IterQueryData,

impl<F0, F1, F2, F3> IterQueryData for AnyOf<(F0, F1, F2, F3)>

where F0: IterQueryData, F1: IterQueryData, F2: IterQueryData, F3: IterQueryData,

impl<F0, F1, F2, F3, F4> IterQueryData for AnyOf<(F0, F1, F2, F3, F4)>

where F0: IterQueryData, F1: IterQueryData, F2: IterQueryData, F3: IterQueryData, F4: IterQueryData,

impl<F0, F1, F2, F3, F4, F5> IterQueryData for AnyOf<(F0, F1, F2, F3, F4, F5)>

where F0: IterQueryData, F1: IterQueryData, F2: IterQueryData, F3: IterQueryData, F4: IterQueryData, F5: IterQueryData,

impl<F0, F1, F2, F3, F4, F5, F6> IterQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6)>

where F0: IterQueryData, F1: IterQueryData, F2: IterQueryData, F3: IterQueryData, F4: IterQueryData, F5: IterQueryData, F6: IterQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7> IterQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)>

where F0: IterQueryData, F1: IterQueryData, F2: IterQueryData, F3: IterQueryData, F4: IterQueryData, F5: IterQueryData, F6: IterQueryData, F7: IterQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8> IterQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)>

where F0: IterQueryData, F1: IterQueryData, F2: IterQueryData, F3: IterQueryData, F4: IterQueryData, F5: IterQueryData, F6: IterQueryData, F7: IterQueryData, F8: IterQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> IterQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)>

where F0: IterQueryData, F1: IterQueryData, F2: IterQueryData, F3: IterQueryData, F4: IterQueryData, F5: IterQueryData, F6: IterQueryData, F7: IterQueryData, F8: IterQueryData, F9: IterQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> IterQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)>

where F0: IterQueryData, F1: IterQueryData, F2: IterQueryData, F3: IterQueryData, F4: IterQueryData, F5: IterQueryData, F6: IterQueryData, F7: IterQueryData, F8: IterQueryData, F9: IterQueryData, F10: IterQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> IterQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)>

where F0: IterQueryData, F1: IterQueryData, F2: IterQueryData, F3: IterQueryData, F4: IterQueryData, F5: IterQueryData, F6: IterQueryData, F7: IterQueryData, F8: IterQueryData, F9: IterQueryData, F10: IterQueryData, F11: IterQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12> IterQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)>

where F0: IterQueryData, F1: IterQueryData, F2: IterQueryData, F3: IterQueryData, F4: IterQueryData, F5: IterQueryData, F6: IterQueryData, F7: IterQueryData, F8: IterQueryData, F9: IterQueryData, F10: IterQueryData, F11: IterQueryData, F12: IterQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13> IterQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)>

where F0: IterQueryData, F1: IterQueryData, F2: IterQueryData, F3: IterQueryData, F4: IterQueryData, F5: IterQueryData, F6: IterQueryData, F7: IterQueryData, F8: IterQueryData, F9: IterQueryData, F10: IterQueryData, F11: IterQueryData, F12: IterQueryData, F13: IterQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14> IterQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)>

where F0: IterQueryData, F1: IterQueryData, F2: IterQueryData, F3: IterQueryData, F4: IterQueryData, F5: IterQueryData, F6: IterQueryData, F7: IterQueryData, F8: IterQueryData, F9: IterQueryData, F10: IterQueryData, F11: IterQueryData, F12: IterQueryData, F13: IterQueryData, F14: IterQueryData,

impl ReadOnlyQueryData for AnyOf<()>

impl<F> ReadOnlyQueryData for AnyOf<(F,)>

where F: ReadOnlyQueryData,

impl<F0, F1> ReadOnlyQueryData for AnyOf<(F0, F1)>

where F0: ReadOnlyQueryData, F1: ReadOnlyQueryData,

impl<F0, F1, F2> ReadOnlyQueryData for AnyOf<(F0, F1, F2)>

where F0: ReadOnlyQueryData, F1: ReadOnlyQueryData, F2: ReadOnlyQueryData,

impl<F0, F1, F2, F3> ReadOnlyQueryData for AnyOf<(F0, F1, F2, F3)>

where F0: ReadOnlyQueryData, F1: ReadOnlyQueryData, F2: ReadOnlyQueryData, F3: ReadOnlyQueryData,

impl<F0, F1, F2, F3, F4> ReadOnlyQueryData for AnyOf<(F0, F1, F2, F3, F4)>

where F0: ReadOnlyQueryData, F1: ReadOnlyQueryData, F2: ReadOnlyQueryData, F3: ReadOnlyQueryData, F4: ReadOnlyQueryData,

impl<F0, F1, F2, F3, F4, F5> ReadOnlyQueryData for AnyOf<(F0, F1, F2, F3, F4, F5)>

where F0: ReadOnlyQueryData, F1: ReadOnlyQueryData, F2: ReadOnlyQueryData, F3: ReadOnlyQueryData, F4: ReadOnlyQueryData, F5: ReadOnlyQueryData,

impl<F0, F1, F2, F3, F4, F5, F6> ReadOnlyQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6)>

where F0: ReadOnlyQueryData, F1: ReadOnlyQueryData, F2: ReadOnlyQueryData, F3: ReadOnlyQueryData, F4: ReadOnlyQueryData, F5: ReadOnlyQueryData, F6: ReadOnlyQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7> ReadOnlyQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)>

where F0: ReadOnlyQueryData, F1: ReadOnlyQueryData, F2: ReadOnlyQueryData, F3: ReadOnlyQueryData, F4: ReadOnlyQueryData, F5: ReadOnlyQueryData, F6: ReadOnlyQueryData, F7: ReadOnlyQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8> ReadOnlyQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)>

where F0: ReadOnlyQueryData, F1: ReadOnlyQueryData, F2: ReadOnlyQueryData, F3: ReadOnlyQueryData, F4: ReadOnlyQueryData, F5: ReadOnlyQueryData, F6: ReadOnlyQueryData, F7: ReadOnlyQueryData, F8: ReadOnlyQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> ReadOnlyQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)>

where F0: ReadOnlyQueryData, F1: ReadOnlyQueryData, F2: ReadOnlyQueryData, F3: ReadOnlyQueryData, F4: ReadOnlyQueryData, F5: ReadOnlyQueryData, F6: ReadOnlyQueryData, F7: ReadOnlyQueryData, F8: ReadOnlyQueryData, F9: ReadOnlyQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> ReadOnlyQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)>

where F0: ReadOnlyQueryData, F1: ReadOnlyQueryData, F2: ReadOnlyQueryData, F3: ReadOnlyQueryData, F4: ReadOnlyQueryData, F5: ReadOnlyQueryData, F6: ReadOnlyQueryData, F7: ReadOnlyQueryData, F8: ReadOnlyQueryData, F9: ReadOnlyQueryData, F10: ReadOnlyQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> ReadOnlyQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)>

where F0: ReadOnlyQueryData, F1: ReadOnlyQueryData, F2: ReadOnlyQueryData, F3: ReadOnlyQueryData, F4: ReadOnlyQueryData, F5: ReadOnlyQueryData, F6: ReadOnlyQueryData, F7: ReadOnlyQueryData, F8: ReadOnlyQueryData, F9: ReadOnlyQueryData, F10: ReadOnlyQueryData, F11: ReadOnlyQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12> ReadOnlyQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)>

where F0: ReadOnlyQueryData, F1: ReadOnlyQueryData, F2: ReadOnlyQueryData, F3: ReadOnlyQueryData, F4: ReadOnlyQueryData, F5: ReadOnlyQueryData, F6: ReadOnlyQueryData, F7: ReadOnlyQueryData, F8: ReadOnlyQueryData, F9: ReadOnlyQueryData, F10: ReadOnlyQueryData, F11: ReadOnlyQueryData, F12: ReadOnlyQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13> ReadOnlyQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)>

where F0: ReadOnlyQueryData, F1: ReadOnlyQueryData, F2: ReadOnlyQueryData, F3: ReadOnlyQueryData, F4: ReadOnlyQueryData, F5: ReadOnlyQueryData, F6: ReadOnlyQueryData, F7: ReadOnlyQueryData, F8: ReadOnlyQueryData, F9: ReadOnlyQueryData, F10: ReadOnlyQueryData, F11: ReadOnlyQueryData, F12: ReadOnlyQueryData, F13: ReadOnlyQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14> ReadOnlyQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)>

where F0: ReadOnlyQueryData, F1: ReadOnlyQueryData, F2: ReadOnlyQueryData, F3: ReadOnlyQueryData, F4: ReadOnlyQueryData, F5: ReadOnlyQueryData, F6: ReadOnlyQueryData, F7: ReadOnlyQueryData, F8: ReadOnlyQueryData, F9: ReadOnlyQueryData, F10: ReadOnlyQueryData, F11: ReadOnlyQueryData, F12: ReadOnlyQueryData, F13: ReadOnlyQueryData, F14: ReadOnlyQueryData,

impl SingleEntityQueryData for AnyOf<()>

impl<F> SingleEntityQueryData for AnyOf<(F,)>

where F: SingleEntityQueryData,

impl<F0, F1> SingleEntityQueryData for AnyOf<(F0, F1)>

where F0: SingleEntityQueryData, F1: SingleEntityQueryData,

impl<F0, F1, F2> SingleEntityQueryData for AnyOf<(F0, F1, F2)>

where F0: SingleEntityQueryData, F1: SingleEntityQueryData, F2: SingleEntityQueryData,

impl<F0, F1, F2, F3> SingleEntityQueryData for AnyOf<(F0, F1, F2, F3)>

where F0: SingleEntityQueryData, F1: SingleEntityQueryData, F2: SingleEntityQueryData, F3: SingleEntityQueryData,

impl<F0, F1, F2, F3, F4> SingleEntityQueryData for AnyOf<(F0, F1, F2, F3, F4)>

where F0: SingleEntityQueryData, F1: SingleEntityQueryData, F2: SingleEntityQueryData, F3: SingleEntityQueryData, F4: SingleEntityQueryData,

impl<F0, F1, F2, F3, F4, F5> SingleEntityQueryData for AnyOf<(F0, F1, F2, F3, F4, F5)>

where F0: SingleEntityQueryData, F1: SingleEntityQueryData, F2: SingleEntityQueryData, F3: SingleEntityQueryData, F4: SingleEntityQueryData, F5: SingleEntityQueryData,

impl<F0, F1, F2, F3, F4, F5, F6> SingleEntityQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6)>

where F0: SingleEntityQueryData, F1: SingleEntityQueryData, F2: SingleEntityQueryData, F3: SingleEntityQueryData, F4: SingleEntityQueryData, F5: SingleEntityQueryData, F6: SingleEntityQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7> SingleEntityQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)>

where F0: SingleEntityQueryData, F1: SingleEntityQueryData, F2: SingleEntityQueryData, F3: SingleEntityQueryData, F4: SingleEntityQueryData, F5: SingleEntityQueryData, F6: SingleEntityQueryData, F7: SingleEntityQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8> SingleEntityQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)>

where F0: SingleEntityQueryData, F1: SingleEntityQueryData, F2: SingleEntityQueryData, F3: SingleEntityQueryData, F4: SingleEntityQueryData, F5: SingleEntityQueryData, F6: SingleEntityQueryData, F7: SingleEntityQueryData, F8: SingleEntityQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> SingleEntityQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)>

where F0: SingleEntityQueryData, F1: SingleEntityQueryData, F2: SingleEntityQueryData, F3: SingleEntityQueryData, F4: SingleEntityQueryData, F5: SingleEntityQueryData, F6: SingleEntityQueryData, F7: SingleEntityQueryData, F8: SingleEntityQueryData, F9: SingleEntityQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> SingleEntityQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)>

where F0: SingleEntityQueryData, F1: SingleEntityQueryData, F2: SingleEntityQueryData, F3: SingleEntityQueryData, F4: SingleEntityQueryData, F5: SingleEntityQueryData, F6: SingleEntityQueryData, F7: SingleEntityQueryData, F8: SingleEntityQueryData, F9: SingleEntityQueryData, F10: SingleEntityQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> SingleEntityQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)>

where F0: SingleEntityQueryData, F1: SingleEntityQueryData, F2: SingleEntityQueryData, F3: SingleEntityQueryData, F4: SingleEntityQueryData, F5: SingleEntityQueryData, F6: SingleEntityQueryData, F7: SingleEntityQueryData, F8: SingleEntityQueryData, F9: SingleEntityQueryData, F10: SingleEntityQueryData, F11: SingleEntityQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12> SingleEntityQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)>

where F0: SingleEntityQueryData, F1: SingleEntityQueryData, F2: SingleEntityQueryData, F3: SingleEntityQueryData, F4: SingleEntityQueryData, F5: SingleEntityQueryData, F6: SingleEntityQueryData, F7: SingleEntityQueryData, F8: SingleEntityQueryData, F9: SingleEntityQueryData, F10: SingleEntityQueryData, F11: SingleEntityQueryData, F12: SingleEntityQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13> SingleEntityQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)>

where F0: SingleEntityQueryData, F1: SingleEntityQueryData, F2: SingleEntityQueryData, F3: SingleEntityQueryData, F4: SingleEntityQueryData, F5: SingleEntityQueryData, F6: SingleEntityQueryData, F7: SingleEntityQueryData, F8: SingleEntityQueryData, F9: SingleEntityQueryData, F10: SingleEntityQueryData, F11: SingleEntityQueryData, F12: SingleEntityQueryData, F13: SingleEntityQueryData,

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14> SingleEntityQueryData for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)>

where F0: SingleEntityQueryData, F1: SingleEntityQueryData, F2: SingleEntityQueryData, F3: SingleEntityQueryData, F4: SingleEntityQueryData, F5: SingleEntityQueryData, F6: SingleEntityQueryData, F7: SingleEntityQueryData, F8: SingleEntityQueryData, F9: SingleEntityQueryData, F10: SingleEntityQueryData, F11: SingleEntityQueryData, F12: SingleEntityQueryData, F13: SingleEntityQueryData, F14: SingleEntityQueryData,