Struct Or 

pub struct Or<T>(pub T);

A filter that tests if any of the given filters apply.

This is useful for example if a system with multiple components in a query only wants to run when one or more of the components have changed.

The And equivalent to this filter is a tuple testing that all the contained filters apply instead.

Examples

fn print_cool_entity_system(query: Query<Entity, Or<(Changed<Color>, Changed<Style>)>>) {
    for entity in &query {
        println!("Entity {:?} got a new style or color", entity);
    }
}

Tuple Fields

0: T

Trait Implementations

impl<T> Clone for Or<T>

where T: Clone,

fn clone(&self) -> Or<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'w> Fetch<'w> for Or<()>

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. This is used to select a more efficient “table iterator” for “dense” queries. If this returns true, Fetch::set_table and Fetch::table_fetch will be called for iterators. If this returns false, Fetch::set_archetype and Fetch::archetype_fetch will be called for iterators.

const IS_ARCHETYPAL: bool = true

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

type State = Or<()>

type Item = bool

unsafe fn init( world: &'w World, state: &Or<()>, last_change_tick: u32, change_tick: u32, ) -> Or<()>

Creates a new instance of this fetch.

unsafe fn set_table( &mut self, state: &<Or<()> as Fetch<'w>>::State, table: &'w Table, )

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

unsafe fn set_archetype( &mut self, state: &<Or<()> as Fetch<'w>>::State, archetype: &'w Archetype, tables: &'w Tables, )

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

unsafe fn table_fetch(&mut self, table_row: usize) -> bool

Fetch Self::Item for the given table_row in the current Table. This must always be called after Fetch::set_table with a table_row in the range of the current Table

unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> bool

Fetch Self::Item for the given archetype_index in the current Archetype. This must always be called after Fetch::set_archetype with an archetype_index in the range of the current Archetype

unsafe fn table_filter_fetch(&mut self, table_row: usize) -> bool

Safety

unsafe fn archetype_filter_fetch(&mut self, archetype_index: usize) -> bool

Safety

fn update_component_access( state: &<Or<()> as Fetch<'w>>::State, access: &mut FilteredAccess<ComponentId>, )

fn update_archetype_component_access( state: &<Or<()> as Fetch<'w>>::State, archetype: &Archetype, access: &mut Access<ArchetypeComponentId>, )

impl<'w, F0> Fetch<'w> for Or<(OrFetch<'w, F0>,)>

where F0: Fetch<'w>,

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. This is used to select a more efficient “table iterator” for “dense” queries. If this returns true, Fetch::set_table and Fetch::table_fetch will be called for iterators. If this returns false, Fetch::set_archetype and Fetch::archetype_fetch will be called for iterators.

const IS_ARCHETYPAL: bool

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

type State = Or<(<F0 as Fetch<'w>>::State,)>

type Item = bool

unsafe fn init( world: &'w World, state: &Or<(<F0 as Fetch<'w>>::State,)>, last_change_tick: u32, change_tick: u32, ) -> Or<(OrFetch<'w, F0>,)>

Creates a new instance of this fetch.

unsafe fn set_table( &mut self, state: &<Or<(OrFetch<'w, F0>,)> as Fetch<'w>>::State, table: &'w Table, )

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

unsafe fn set_archetype( &mut self, state: &<Or<(OrFetch<'w, F0>,)> as Fetch<'w>>::State, archetype: &'w Archetype, tables: &'w Tables, )

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

unsafe fn table_fetch(&mut self, table_row: usize) -> bool

Fetch Self::Item for the given table_row in the current Table. This must always be called after Fetch::set_table with a table_row in the range of the current Table

unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> bool

Fetch Self::Item for the given archetype_index in the current Archetype. This must always be called after Fetch::set_archetype with an archetype_index in the range of the current Archetype

unsafe fn table_filter_fetch(&mut self, table_row: usize) -> bool

Safety

unsafe fn archetype_filter_fetch(&mut self, archetype_index: usize) -> bool

Safety

fn update_component_access( state: &<Or<(OrFetch<'w, F0>,)> as Fetch<'w>>::State, access: &mut FilteredAccess<ComponentId>, )

fn update_archetype_component_access( state: &<Or<(OrFetch<'w, F0>,)> as Fetch<'w>>::State, archetype: &Archetype, access: &mut Access<ArchetypeComponentId>, )

impl<'w, F0, F1> Fetch<'w> for Or<(OrFetch<'w, F0>, OrFetch<'w, F1>)>

where F0: Fetch<'w>, F1: Fetch<'w>,

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. This is used to select a more efficient “table iterator” for “dense” queries. If this returns true, Fetch::set_table and Fetch::table_fetch will be called for iterators. If this returns false, Fetch::set_archetype and Fetch::archetype_fetch will be called for iterators.

const IS_ARCHETYPAL: bool

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

type State = Or<(<F0 as Fetch<'w>>::State, <F1 as Fetch<'w>>::State)>

type Item = bool

unsafe fn init( world: &'w World, state: &Or<(<F0 as Fetch<'w>>::State, <F1 as Fetch<'w>>::State)>, last_change_tick: u32, change_tick: u32, ) -> Or<(OrFetch<'w, F0>, OrFetch<'w, F1>)>

Creates a new instance of this fetch.

unsafe fn set_table( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>)> as Fetch<'w>>::State, table: &'w Table, )

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

unsafe fn set_archetype( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>)> as Fetch<'w>>::State, archetype: &'w Archetype, tables: &'w Tables, )

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

unsafe fn table_fetch(&mut self, table_row: usize) -> bool

Fetch Self::Item for the given table_row in the current Table. This must always be called after Fetch::set_table with a table_row in the range of the current Table

unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> bool

Fetch Self::Item for the given archetype_index in the current Archetype. This must always be called after Fetch::set_archetype with an archetype_index in the range of the current Archetype

unsafe fn table_filter_fetch(&mut self, table_row: usize) -> bool

Safety

unsafe fn archetype_filter_fetch(&mut self, archetype_index: usize) -> bool

Safety

fn update_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>)> as Fetch<'w>>::State, access: &mut FilteredAccess<ComponentId>, )

fn update_archetype_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>)> as Fetch<'w>>::State, archetype: &Archetype, access: &mut Access<ArchetypeComponentId>, )

impl<'w, F0, F1, F2> Fetch<'w> for Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>)>

where F0: Fetch<'w>, F1: Fetch<'w>, F2: Fetch<'w>,

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. This is used to select a more efficient “table iterator” for “dense” queries. If this returns true, Fetch::set_table and Fetch::table_fetch will be called for iterators. If this returns false, Fetch::set_archetype and Fetch::archetype_fetch will be called for iterators.

const IS_ARCHETYPAL: bool

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

type State = Or<(<F0 as Fetch<'w>>::State, <F1 as Fetch<'w>>::State, <F2 as Fetch<'w>>::State)>

type Item = bool

unsafe fn init( world: &'w World, state: &Or<(<F0 as Fetch<'w>>::State, <F1 as Fetch<'w>>::State, <F2 as Fetch<'w>>::State)>, last_change_tick: u32, change_tick: u32, ) -> Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>)>

Creates a new instance of this fetch.

unsafe fn set_table( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>)> as Fetch<'w>>::State, table: &'w Table, )

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

unsafe fn set_archetype( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>)> as Fetch<'w>>::State, archetype: &'w Archetype, tables: &'w Tables, )

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

unsafe fn table_fetch(&mut self, table_row: usize) -> bool

Fetch Self::Item for the given table_row in the current Table. This must always be called after Fetch::set_table with a table_row in the range of the current Table

unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> bool

Fetch Self::Item for the given archetype_index in the current Archetype. This must always be called after Fetch::set_archetype with an archetype_index in the range of the current Archetype

unsafe fn table_filter_fetch(&mut self, table_row: usize) -> bool

Safety

unsafe fn archetype_filter_fetch(&mut self, archetype_index: usize) -> bool

Safety

fn update_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>)> as Fetch<'w>>::State, access: &mut FilteredAccess<ComponentId>, )

fn update_archetype_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>)> as Fetch<'w>>::State, archetype: &Archetype, access: &mut Access<ArchetypeComponentId>, )

impl<'w, F0, F1, F2, F3> Fetch<'w> for Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>)>

where F0: Fetch<'w>, F1: Fetch<'w>, F2: Fetch<'w>, F3: Fetch<'w>,

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. This is used to select a more efficient “table iterator” for “dense” queries. If this returns true, Fetch::set_table and Fetch::table_fetch will be called for iterators. If this returns false, Fetch::set_archetype and Fetch::archetype_fetch will be called for iterators.

const IS_ARCHETYPAL: bool

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

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

type Item = bool

unsafe fn init( world: &'w World, state: &Or<(<F0 as Fetch<'w>>::State, <F1 as Fetch<'w>>::State, <F2 as Fetch<'w>>::State, <F3 as Fetch<'w>>::State)>, last_change_tick: u32, change_tick: u32, ) -> Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>)>

Creates a new instance of this fetch.

unsafe fn set_table( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>)> as Fetch<'w>>::State, table: &'w Table, )

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

unsafe fn set_archetype( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>)> as Fetch<'w>>::State, archetype: &'w Archetype, tables: &'w Tables, )

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

unsafe fn table_fetch(&mut self, table_row: usize) -> bool

Fetch Self::Item for the given table_row in the current Table. This must always be called after Fetch::set_table with a table_row in the range of the current Table

unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> bool

Fetch Self::Item for the given archetype_index in the current Archetype. This must always be called after Fetch::set_archetype with an archetype_index in the range of the current Archetype

unsafe fn table_filter_fetch(&mut self, table_row: usize) -> bool

Safety

unsafe fn archetype_filter_fetch(&mut self, archetype_index: usize) -> bool

Safety

fn update_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>)> as Fetch<'w>>::State, access: &mut FilteredAccess<ComponentId>, )

fn update_archetype_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>)> as Fetch<'w>>::State, archetype: &Archetype, access: &mut Access<ArchetypeComponentId>, )

impl<'w, F0, F1, F2, F3, F4> Fetch<'w> for Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>)>

where F0: Fetch<'w>, F1: Fetch<'w>, F2: Fetch<'w>, F3: Fetch<'w>, F4: Fetch<'w>,

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. This is used to select a more efficient “table iterator” for “dense” queries. If this returns true, Fetch::set_table and Fetch::table_fetch will be called for iterators. If this returns false, Fetch::set_archetype and Fetch::archetype_fetch will be called for iterators.

const IS_ARCHETYPAL: bool

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

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

type Item = bool

unsafe fn init( world: &'w World, state: &Or<(<F0 as Fetch<'w>>::State, <F1 as Fetch<'w>>::State, <F2 as Fetch<'w>>::State, <F3 as Fetch<'w>>::State, <F4 as Fetch<'w>>::State)>, last_change_tick: u32, change_tick: u32, ) -> Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>)>

Creates a new instance of this fetch.

unsafe fn set_table( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>)> as Fetch<'w>>::State, table: &'w Table, )

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

unsafe fn set_archetype( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>)> as Fetch<'w>>::State, archetype: &'w Archetype, tables: &'w Tables, )

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

unsafe fn table_fetch(&mut self, table_row: usize) -> bool

Fetch Self::Item for the given table_row in the current Table. This must always be called after Fetch::set_table with a table_row in the range of the current Table

unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> bool

Fetch Self::Item for the given archetype_index in the current Archetype. This must always be called after Fetch::set_archetype with an archetype_index in the range of the current Archetype

unsafe fn table_filter_fetch(&mut self, table_row: usize) -> bool

Safety

unsafe fn archetype_filter_fetch(&mut self, archetype_index: usize) -> bool

Safety

fn update_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>)> as Fetch<'w>>::State, access: &mut FilteredAccess<ComponentId>, )

fn update_archetype_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>)> as Fetch<'w>>::State, archetype: &Archetype, access: &mut Access<ArchetypeComponentId>, )

impl<'w, F0, F1, F2, F3, F4, F5> Fetch<'w> for Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>)>

where F0: Fetch<'w>, F1: Fetch<'w>, F2: Fetch<'w>, F3: Fetch<'w>, F4: Fetch<'w>, F5: Fetch<'w>,

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. This is used to select a more efficient “table iterator” for “dense” queries. If this returns true, Fetch::set_table and Fetch::table_fetch will be called for iterators. If this returns false, Fetch::set_archetype and Fetch::archetype_fetch will be called for iterators.

const IS_ARCHETYPAL: bool

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

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

type Item = bool

unsafe fn init( world: &'w World, state: &Or<(<F0 as Fetch<'w>>::State, <F1 as Fetch<'w>>::State, <F2 as Fetch<'w>>::State, <F3 as Fetch<'w>>::State, <F4 as Fetch<'w>>::State, <F5 as Fetch<'w>>::State)>, last_change_tick: u32, change_tick: u32, ) -> Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>)>

Creates a new instance of this fetch.

unsafe fn set_table( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>)> as Fetch<'w>>::State, table: &'w Table, )

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

unsafe fn set_archetype( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>)> as Fetch<'w>>::State, archetype: &'w Archetype, tables: &'w Tables, )

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

unsafe fn table_fetch(&mut self, table_row: usize) -> bool

Fetch Self::Item for the given table_row in the current Table. This must always be called after Fetch::set_table with a table_row in the range of the current Table

unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> bool

Fetch Self::Item for the given archetype_index in the current Archetype. This must always be called after Fetch::set_archetype with an archetype_index in the range of the current Archetype

unsafe fn table_filter_fetch(&mut self, table_row: usize) -> bool

Safety

unsafe fn archetype_filter_fetch(&mut self, archetype_index: usize) -> bool

Safety

fn update_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>)> as Fetch<'w>>::State, access: &mut FilteredAccess<ComponentId>, )

fn update_archetype_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>)> as Fetch<'w>>::State, archetype: &Archetype, access: &mut Access<ArchetypeComponentId>, )

impl<'w, F0, F1, F2, F3, F4, F5, F6> Fetch<'w> for Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>)>

where F0: Fetch<'w>, F1: Fetch<'w>, F2: Fetch<'w>, F3: Fetch<'w>, F4: Fetch<'w>, F5: Fetch<'w>, F6: Fetch<'w>,

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. This is used to select a more efficient “table iterator” for “dense” queries. If this returns true, Fetch::set_table and Fetch::table_fetch will be called for iterators. If this returns false, Fetch::set_archetype and Fetch::archetype_fetch will be called for iterators.

const IS_ARCHETYPAL: bool

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

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

type Item = bool

unsafe fn init( world: &'w World, state: &Or<(<F0 as Fetch<'w>>::State, <F1 as Fetch<'w>>::State, <F2 as Fetch<'w>>::State, <F3 as Fetch<'w>>::State, <F4 as Fetch<'w>>::State, <F5 as Fetch<'w>>::State, <F6 as Fetch<'w>>::State)>, last_change_tick: u32, change_tick: u32, ) -> Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>)>

Creates a new instance of this fetch.

unsafe fn set_table( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>)> as Fetch<'w>>::State, table: &'w Table, )

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

unsafe fn set_archetype( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>)> as Fetch<'w>>::State, archetype: &'w Archetype, tables: &'w Tables, )

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

unsafe fn table_fetch(&mut self, table_row: usize) -> bool

Fetch Self::Item for the given table_row in the current Table. This must always be called after Fetch::set_table with a table_row in the range of the current Table

unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> bool

Fetch Self::Item for the given archetype_index in the current Archetype. This must always be called after Fetch::set_archetype with an archetype_index in the range of the current Archetype

unsafe fn table_filter_fetch(&mut self, table_row: usize) -> bool

Safety

unsafe fn archetype_filter_fetch(&mut self, archetype_index: usize) -> bool

Safety

fn update_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>)> as Fetch<'w>>::State, access: &mut FilteredAccess<ComponentId>, )

fn update_archetype_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>)> as Fetch<'w>>::State, archetype: &Archetype, access: &mut Access<ArchetypeComponentId>, )

impl<'w, F0, F1, F2, F3, F4, F5, F6, F7> Fetch<'w> for Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>)>

where F0: Fetch<'w>, F1: Fetch<'w>, F2: Fetch<'w>, F3: Fetch<'w>, F4: Fetch<'w>, F5: Fetch<'w>, F6: Fetch<'w>, F7: Fetch<'w>,

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. This is used to select a more efficient “table iterator” for “dense” queries. If this returns true, Fetch::set_table and Fetch::table_fetch will be called for iterators. If this returns false, Fetch::set_archetype and Fetch::archetype_fetch will be called for iterators.

const IS_ARCHETYPAL: bool

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

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

type Item = bool

unsafe fn init( world: &'w World, state: &Or<(<F0 as Fetch<'w>>::State, <F1 as Fetch<'w>>::State, <F2 as Fetch<'w>>::State, <F3 as Fetch<'w>>::State, <F4 as Fetch<'w>>::State, <F5 as Fetch<'w>>::State, <F6 as Fetch<'w>>::State, <F7 as Fetch<'w>>::State)>, last_change_tick: u32, change_tick: u32, ) -> Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>)>

Creates a new instance of this fetch.

unsafe fn set_table( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>)> as Fetch<'w>>::State, table: &'w Table, )

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

unsafe fn set_archetype( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>)> as Fetch<'w>>::State, archetype: &'w Archetype, tables: &'w Tables, )

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

unsafe fn table_fetch(&mut self, table_row: usize) -> bool

Fetch Self::Item for the given table_row in the current Table. This must always be called after Fetch::set_table with a table_row in the range of the current Table

unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> bool

Fetch Self::Item for the given archetype_index in the current Archetype. This must always be called after Fetch::set_archetype with an archetype_index in the range of the current Archetype

unsafe fn table_filter_fetch(&mut self, table_row: usize) -> bool

Safety

unsafe fn archetype_filter_fetch(&mut self, archetype_index: usize) -> bool

Safety

fn update_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>)> as Fetch<'w>>::State, access: &mut FilteredAccess<ComponentId>, )

fn update_archetype_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>)> as Fetch<'w>>::State, archetype: &Archetype, access: &mut Access<ArchetypeComponentId>, )

impl<'w, F0, F1, F2, F3, F4, F5, F6, F7, F8> Fetch<'w> for Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>)>

where F0: Fetch<'w>, F1: Fetch<'w>, F2: Fetch<'w>, F3: Fetch<'w>, F4: Fetch<'w>, F5: Fetch<'w>, F6: Fetch<'w>, F7: Fetch<'w>, F8: Fetch<'w>,

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. This is used to select a more efficient “table iterator” for “dense” queries. If this returns true, Fetch::set_table and Fetch::table_fetch will be called for iterators. If this returns false, Fetch::set_archetype and Fetch::archetype_fetch will be called for iterators.

const IS_ARCHETYPAL: bool

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

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

type Item = bool

unsafe fn init( world: &'w World, state: &Or<(<F0 as Fetch<'w>>::State, <F1 as Fetch<'w>>::State, <F2 as Fetch<'w>>::State, <F3 as Fetch<'w>>::State, <F4 as Fetch<'w>>::State, <F5 as Fetch<'w>>::State, <F6 as Fetch<'w>>::State, <F7 as Fetch<'w>>::State, <F8 as Fetch<'w>>::State)>, last_change_tick: u32, change_tick: u32, ) -> Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>)>

Creates a new instance of this fetch.

unsafe fn set_table( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>)> as Fetch<'w>>::State, table: &'w Table, )

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

unsafe fn set_archetype( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>)> as Fetch<'w>>::State, archetype: &'w Archetype, tables: &'w Tables, )

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

unsafe fn table_fetch(&mut self, table_row: usize) -> bool

Fetch Self::Item for the given table_row in the current Table. This must always be called after Fetch::set_table with a table_row in the range of the current Table

unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> bool

Fetch Self::Item for the given archetype_index in the current Archetype. This must always be called after Fetch::set_archetype with an archetype_index in the range of the current Archetype

unsafe fn table_filter_fetch(&mut self, table_row: usize) -> bool

Safety

unsafe fn archetype_filter_fetch(&mut self, archetype_index: usize) -> bool

Safety

fn update_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>)> as Fetch<'w>>::State, access: &mut FilteredAccess<ComponentId>, )

fn update_archetype_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>)> as Fetch<'w>>::State, archetype: &Archetype, access: &mut Access<ArchetypeComponentId>, )

impl<'w, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> Fetch<'w> for Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>)>

where F0: Fetch<'w>, F1: Fetch<'w>, F2: Fetch<'w>, F3: Fetch<'w>, F4: Fetch<'w>, F5: Fetch<'w>, F6: Fetch<'w>, F7: Fetch<'w>, F8: Fetch<'w>, F9: Fetch<'w>,

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. This is used to select a more efficient “table iterator” for “dense” queries. If this returns true, Fetch::set_table and Fetch::table_fetch will be called for iterators. If this returns false, Fetch::set_archetype and Fetch::archetype_fetch will be called for iterators.

const IS_ARCHETYPAL: bool

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

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

type Item = bool

unsafe fn init( world: &'w World, state: &Or<(<F0 as Fetch<'w>>::State, <F1 as Fetch<'w>>::State, <F2 as Fetch<'w>>::State, <F3 as Fetch<'w>>::State, <F4 as Fetch<'w>>::State, <F5 as Fetch<'w>>::State, <F6 as Fetch<'w>>::State, <F7 as Fetch<'w>>::State, <F8 as Fetch<'w>>::State, <F9 as Fetch<'w>>::State)>, last_change_tick: u32, change_tick: u32, ) -> Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>)>

Creates a new instance of this fetch.

unsafe fn set_table( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>)> as Fetch<'w>>::State, table: &'w Table, )

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

unsafe fn set_archetype( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>)> as Fetch<'w>>::State, archetype: &'w Archetype, tables: &'w Tables, )

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

unsafe fn table_fetch(&mut self, table_row: usize) -> bool

Fetch Self::Item for the given table_row in the current Table. This must always be called after Fetch::set_table with a table_row in the range of the current Table

unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> bool

Fetch Self::Item for the given archetype_index in the current Archetype. This must always be called after Fetch::set_archetype with an archetype_index in the range of the current Archetype

unsafe fn table_filter_fetch(&mut self, table_row: usize) -> bool

Safety

unsafe fn archetype_filter_fetch(&mut self, archetype_index: usize) -> bool

Safety

fn update_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>)> as Fetch<'w>>::State, access: &mut FilteredAccess<ComponentId>, )

fn update_archetype_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>)> as Fetch<'w>>::State, archetype: &Archetype, access: &mut Access<ArchetypeComponentId>, )

impl<'w, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> Fetch<'w> for Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>)>

where F0: Fetch<'w>, F1: Fetch<'w>, F2: Fetch<'w>, F3: Fetch<'w>, F4: Fetch<'w>, F5: Fetch<'w>, F6: Fetch<'w>, F7: Fetch<'w>, F8: Fetch<'w>, F9: Fetch<'w>, F10: Fetch<'w>,

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. This is used to select a more efficient “table iterator” for “dense” queries. If this returns true, Fetch::set_table and Fetch::table_fetch will be called for iterators. If this returns false, Fetch::set_archetype and Fetch::archetype_fetch will be called for iterators.

const IS_ARCHETYPAL: bool

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

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

type Item = bool

unsafe fn init( world: &'w World, state: &Or<(<F0 as Fetch<'w>>::State, <F1 as Fetch<'w>>::State, <F2 as Fetch<'w>>::State, <F3 as Fetch<'w>>::State, <F4 as Fetch<'w>>::State, <F5 as Fetch<'w>>::State, <F6 as Fetch<'w>>::State, <F7 as Fetch<'w>>::State, <F8 as Fetch<'w>>::State, <F9 as Fetch<'w>>::State, <F10 as Fetch<'w>>::State)>, last_change_tick: u32, change_tick: u32, ) -> Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>)>

Creates a new instance of this fetch.

unsafe fn set_table( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>)> as Fetch<'w>>::State, table: &'w Table, )

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

unsafe fn set_archetype( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>)> as Fetch<'w>>::State, archetype: &'w Archetype, tables: &'w Tables, )

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

unsafe fn table_fetch(&mut self, table_row: usize) -> bool

Fetch Self::Item for the given table_row in the current Table. This must always be called after Fetch::set_table with a table_row in the range of the current Table

unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> bool

Fetch Self::Item for the given archetype_index in the current Archetype. This must always be called after Fetch::set_archetype with an archetype_index in the range of the current Archetype

unsafe fn table_filter_fetch(&mut self, table_row: usize) -> bool

Safety

unsafe fn archetype_filter_fetch(&mut self, archetype_index: usize) -> bool

Safety

fn update_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>)> as Fetch<'w>>::State, access: &mut FilteredAccess<ComponentId>, )

fn update_archetype_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>)> as Fetch<'w>>::State, archetype: &Archetype, access: &mut Access<ArchetypeComponentId>, )

impl<'w, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> Fetch<'w> for Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>)>

where F0: Fetch<'w>, F1: Fetch<'w>, F2: Fetch<'w>, F3: Fetch<'w>, F4: Fetch<'w>, F5: Fetch<'w>, F6: Fetch<'w>, F7: Fetch<'w>, F8: Fetch<'w>, F9: Fetch<'w>, F10: Fetch<'w>, F11: Fetch<'w>,

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. This is used to select a more efficient “table iterator” for “dense” queries. If this returns true, Fetch::set_table and Fetch::table_fetch will be called for iterators. If this returns false, Fetch::set_archetype and Fetch::archetype_fetch will be called for iterators.

const IS_ARCHETYPAL: bool

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

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

type Item = bool

unsafe fn init( world: &'w World, state: &Or<(<F0 as Fetch<'w>>::State, <F1 as Fetch<'w>>::State, <F2 as Fetch<'w>>::State, <F3 as Fetch<'w>>::State, <F4 as Fetch<'w>>::State, <F5 as Fetch<'w>>::State, <F6 as Fetch<'w>>::State, <F7 as Fetch<'w>>::State, <F8 as Fetch<'w>>::State, <F9 as Fetch<'w>>::State, <F10 as Fetch<'w>>::State, <F11 as Fetch<'w>>::State)>, last_change_tick: u32, change_tick: u32, ) -> Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>)>

Creates a new instance of this fetch.

unsafe fn set_table( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>)> as Fetch<'w>>::State, table: &'w Table, )

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

unsafe fn set_archetype( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>)> as Fetch<'w>>::State, archetype: &'w Archetype, tables: &'w Tables, )

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

unsafe fn table_fetch(&mut self, table_row: usize) -> bool

Fetch Self::Item for the given table_row in the current Table. This must always be called after Fetch::set_table with a table_row in the range of the current Table

unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> bool

Fetch Self::Item for the given archetype_index in the current Archetype. This must always be called after Fetch::set_archetype with an archetype_index in the range of the current Archetype

unsafe fn table_filter_fetch(&mut self, table_row: usize) -> bool

Safety

unsafe fn archetype_filter_fetch(&mut self, archetype_index: usize) -> bool

Safety

fn update_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>)> as Fetch<'w>>::State, access: &mut FilteredAccess<ComponentId>, )

fn update_archetype_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>)> as Fetch<'w>>::State, archetype: &Archetype, access: &mut Access<ArchetypeComponentId>, )

impl<'w, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12> Fetch<'w> for Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>, OrFetch<'w, F12>)>

where F0: Fetch<'w>, F1: Fetch<'w>, F2: Fetch<'w>, F3: Fetch<'w>, F4: Fetch<'w>, F5: Fetch<'w>, F6: Fetch<'w>, F7: Fetch<'w>, F8: Fetch<'w>, F9: Fetch<'w>, F10: Fetch<'w>, F11: Fetch<'w>, F12: Fetch<'w>,

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. This is used to select a more efficient “table iterator” for “dense” queries. If this returns true, Fetch::set_table and Fetch::table_fetch will be called for iterators. If this returns false, Fetch::set_archetype and Fetch::archetype_fetch will be called for iterators.

const IS_ARCHETYPAL: bool

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

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

type Item = bool

unsafe fn init( world: &'w World, state: &Or<(<F0 as Fetch<'w>>::State, <F1 as Fetch<'w>>::State, <F2 as Fetch<'w>>::State, <F3 as Fetch<'w>>::State, <F4 as Fetch<'w>>::State, <F5 as Fetch<'w>>::State, <F6 as Fetch<'w>>::State, <F7 as Fetch<'w>>::State, <F8 as Fetch<'w>>::State, <F9 as Fetch<'w>>::State, <F10 as Fetch<'w>>::State, <F11 as Fetch<'w>>::State, <F12 as Fetch<'w>>::State)>, last_change_tick: u32, change_tick: u32, ) -> Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>, OrFetch<'w, F12>)>

Creates a new instance of this fetch.

unsafe fn set_table( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>, OrFetch<'w, F12>)> as Fetch<'w>>::State, table: &'w Table, )

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

unsafe fn set_archetype( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>, OrFetch<'w, F12>)> as Fetch<'w>>::State, archetype: &'w Archetype, tables: &'w Tables, )

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

unsafe fn table_fetch(&mut self, table_row: usize) -> bool

Fetch Self::Item for the given table_row in the current Table. This must always be called after Fetch::set_table with a table_row in the range of the current Table

unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> bool

Fetch Self::Item for the given archetype_index in the current Archetype. This must always be called after Fetch::set_archetype with an archetype_index in the range of the current Archetype

unsafe fn table_filter_fetch(&mut self, table_row: usize) -> bool

Safety

unsafe fn archetype_filter_fetch(&mut self, archetype_index: usize) -> bool

Safety

fn update_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>, OrFetch<'w, F12>)> as Fetch<'w>>::State, access: &mut FilteredAccess<ComponentId>, )

fn update_archetype_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>, OrFetch<'w, F12>)> as Fetch<'w>>::State, archetype: &Archetype, access: &mut Access<ArchetypeComponentId>, )

impl<'w, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13> Fetch<'w> for Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>, OrFetch<'w, F12>, OrFetch<'w, F13>)>

where F0: Fetch<'w>, F1: Fetch<'w>, F2: Fetch<'w>, F3: Fetch<'w>, F4: Fetch<'w>, F5: Fetch<'w>, F6: Fetch<'w>, F7: Fetch<'w>, F8: Fetch<'w>, F9: Fetch<'w>, F10: Fetch<'w>, F11: Fetch<'w>, F12: Fetch<'w>, F13: Fetch<'w>,

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. This is used to select a more efficient “table iterator” for “dense” queries. If this returns true, Fetch::set_table and Fetch::table_fetch will be called for iterators. If this returns false, Fetch::set_archetype and Fetch::archetype_fetch will be called for iterators.

const IS_ARCHETYPAL: bool

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

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

type Item = bool

unsafe fn init( world: &'w World, state: &Or<(<F0 as Fetch<'w>>::State, <F1 as Fetch<'w>>::State, <F2 as Fetch<'w>>::State, <F3 as Fetch<'w>>::State, <F4 as Fetch<'w>>::State, <F5 as Fetch<'w>>::State, <F6 as Fetch<'w>>::State, <F7 as Fetch<'w>>::State, <F8 as Fetch<'w>>::State, <F9 as Fetch<'w>>::State, <F10 as Fetch<'w>>::State, <F11 as Fetch<'w>>::State, <F12 as Fetch<'w>>::State, <F13 as Fetch<'w>>::State)>, last_change_tick: u32, change_tick: u32, ) -> Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>, OrFetch<'w, F12>, OrFetch<'w, F13>)>

Creates a new instance of this fetch.

unsafe fn set_table( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>, OrFetch<'w, F12>, OrFetch<'w, F13>)> as Fetch<'w>>::State, table: &'w Table, )

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

unsafe fn set_archetype( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>, OrFetch<'w, F12>, OrFetch<'w, F13>)> as Fetch<'w>>::State, archetype: &'w Archetype, tables: &'w Tables, )

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

unsafe fn table_fetch(&mut self, table_row: usize) -> bool

Fetch Self::Item for the given table_row in the current Table. This must always be called after Fetch::set_table with a table_row in the range of the current Table

unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> bool

Fetch Self::Item for the given archetype_index in the current Archetype. This must always be called after Fetch::set_archetype with an archetype_index in the range of the current Archetype

unsafe fn table_filter_fetch(&mut self, table_row: usize) -> bool

Safety

unsafe fn archetype_filter_fetch(&mut self, archetype_index: usize) -> bool

Safety

fn update_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>, OrFetch<'w, F12>, OrFetch<'w, F13>)> as Fetch<'w>>::State, access: &mut FilteredAccess<ComponentId>, )

fn update_archetype_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>, OrFetch<'w, F12>, OrFetch<'w, F13>)> as Fetch<'w>>::State, archetype: &Archetype, access: &mut Access<ArchetypeComponentId>, )

impl<'w, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14> Fetch<'w> for Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>, OrFetch<'w, F12>, OrFetch<'w, F13>, OrFetch<'w, F14>)>

where F0: Fetch<'w>, F1: Fetch<'w>, F2: Fetch<'w>, F3: Fetch<'w>, F4: Fetch<'w>, F5: Fetch<'w>, F6: Fetch<'w>, F7: Fetch<'w>, F8: Fetch<'w>, F9: Fetch<'w>, F10: Fetch<'w>, F11: Fetch<'w>, F12: Fetch<'w>, F13: Fetch<'w>, F14: Fetch<'w>,

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. This is used to select a more efficient “table iterator” for “dense” queries. If this returns true, Fetch::set_table and Fetch::table_fetch will be called for iterators. If this returns false, Fetch::set_archetype and Fetch::archetype_fetch will be called for iterators.

const IS_ARCHETYPAL: bool

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

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

type Item = bool

unsafe fn init( world: &'w World, state: &Or<(<F0 as Fetch<'w>>::State, <F1 as Fetch<'w>>::State, <F2 as Fetch<'w>>::State, <F3 as Fetch<'w>>::State, <F4 as Fetch<'w>>::State, <F5 as Fetch<'w>>::State, <F6 as Fetch<'w>>::State, <F7 as Fetch<'w>>::State, <F8 as Fetch<'w>>::State, <F9 as Fetch<'w>>::State, <F10 as Fetch<'w>>::State, <F11 as Fetch<'w>>::State, <F12 as Fetch<'w>>::State, <F13 as Fetch<'w>>::State, <F14 as Fetch<'w>>::State)>, last_change_tick: u32, change_tick: u32, ) -> Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>, OrFetch<'w, F12>, OrFetch<'w, F13>, OrFetch<'w, F14>)>

Creates a new instance of this fetch.

unsafe fn set_table( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>, OrFetch<'w, F12>, OrFetch<'w, F13>, OrFetch<'w, F14>)> as Fetch<'w>>::State, table: &'w Table, )

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

unsafe fn set_archetype( &mut self, state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>, OrFetch<'w, F12>, OrFetch<'w, F13>, OrFetch<'w, F14>)> as Fetch<'w>>::State, archetype: &'w Archetype, tables: &'w Tables, )

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

unsafe fn table_fetch(&mut self, table_row: usize) -> bool

Fetch Self::Item for the given table_row in the current Table. This must always be called after Fetch::set_table with a table_row in the range of the current Table

unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> bool

Fetch Self::Item for the given archetype_index in the current Archetype. This must always be called after Fetch::set_archetype with an archetype_index in the range of the current Archetype

unsafe fn table_filter_fetch(&mut self, table_row: usize) -> bool

Safety

unsafe fn archetype_filter_fetch(&mut self, archetype_index: usize) -> bool

Safety

fn update_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>, OrFetch<'w, F12>, OrFetch<'w, F13>, OrFetch<'w, F14>)> as Fetch<'w>>::State, access: &mut FilteredAccess<ComponentId>, )

fn update_archetype_component_access( state: &<Or<(OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>, OrFetch<'w, F12>, OrFetch<'w, F13>, OrFetch<'w, F14>)> as Fetch<'w>>::State, archetype: &Archetype, access: &mut Access<ArchetypeComponentId>, )

impl FetchState for Or<()>

fn init(world: &mut World) -> Or<()>

fn matches_component_set( &self, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

impl<F0> FetchState for Or<(F0,)>

where F0: FetchState,

fn init(world: &mut World) -> Or<(F0,)>

fn matches_component_set( &self, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

impl<F0, F1> FetchState for Or<(F0, F1)>

where F0: FetchState, F1: FetchState,

fn init(world: &mut World) -> Or<(F0, F1)>

fn matches_component_set( &self, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

impl<F0, F1, F2> FetchState for Or<(F0, F1, F2)>

where F0: FetchState, F1: FetchState, F2: FetchState,

fn init(world: &mut World) -> Or<(F0, F1, F2)>

fn matches_component_set( &self, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

impl<F0, F1, F2, F3> FetchState for Or<(F0, F1, F2, F3)>

where F0: FetchState, F1: FetchState, F2: FetchState, F3: FetchState,

fn init(world: &mut World) -> Or<(F0, F1, F2, F3)>

fn matches_component_set( &self, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

impl<F0, F1, F2, F3, F4> FetchState for Or<(F0, F1, F2, F3, F4)>

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

fn init(world: &mut World) -> Or<(F0, F1, F2, F3, F4)>

fn matches_component_set( &self, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

impl<F0, F1, F2, F3, F4, F5> FetchState for Or<(F0, F1, F2, F3, F4, F5)>

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

fn init(world: &mut World) -> Or<(F0, F1, F2, F3, F4, F5)>

fn matches_component_set( &self, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

impl<F0, F1, F2, F3, F4, F5, F6> FetchState for Or<(F0, F1, F2, F3, F4, F5, F6)>

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

fn init(world: &mut World) -> Or<(F0, F1, F2, F3, F4, F5, F6)>

fn matches_component_set( &self, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

impl<F0, F1, F2, F3, F4, F5, F6, F7> FetchState for Or<(F0, F1, F2, F3, F4, F5, F6, F7)>

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

fn init(world: &mut World) -> Or<(F0, F1, F2, F3, F4, F5, F6, F7)>

fn matches_component_set( &self, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

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

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

fn init(world: &mut World) -> Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8)>

fn matches_component_set( &self, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

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

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

fn init(world: &mut World) -> Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)>

fn matches_component_set( &self, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

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

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

fn init(world: &mut World) -> Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)>

fn matches_component_set( &self, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

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

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

fn init( world: &mut World, ) -> Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)>

fn matches_component_set( &self, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

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

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

fn init( world: &mut World, ) -> Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)>

fn matches_component_set( &self, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

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

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

fn init( world: &mut World, ) -> Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)>

fn matches_component_set( &self, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

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

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

fn init( world: &mut World, ) -> Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)>

fn matches_component_set( &self, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool

impl WorldQuery for Or<()>

type ReadOnly = Or<()>

type State = Or<()>

fn shrink<'wlong, 'wshort>( item: <<Or<()> as WorldQueryGats<'wlong>>::Fetch as Fetch<'wlong>>::Item, ) -> <<Or<()> as WorldQueryGats<'wshort>>::Fetch as Fetch<'wshort>>::Item

where 'wlong: 'wshort,

This function manually implements variance for the query items.

impl<F0> WorldQuery for Or<(F0,)>

where F0: WorldQuery,

type ReadOnly = Or<(<F0 as WorldQuery>::ReadOnly,)>

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

fn shrink<'wlong, 'wshort>( item: <<Or<(F0,)> as WorldQueryGats<'wlong>>::Fetch as Fetch<'wlong>>::Item, ) -> <<Or<(F0,)> as WorldQueryGats<'wshort>>::Fetch as Fetch<'wshort>>::Item

where 'wlong: 'wshort,

This function manually implements variance for the query items.

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

where F0: WorldQuery, F1: WorldQuery,

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

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

fn shrink<'wlong, 'wshort>( item: <<Or<(F0, F1)> as WorldQueryGats<'wlong>>::Fetch as Fetch<'wlong>>::Item, ) -> <<Or<(F0, F1)> as WorldQueryGats<'wshort>>::Fetch as Fetch<'wshort>>::Item

where 'wlong: 'wshort,

This function manually implements variance for the query items.

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

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

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

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

fn shrink<'wlong, 'wshort>( item: <<Or<(F0, F1, F2)> as WorldQueryGats<'wlong>>::Fetch as Fetch<'wlong>>::Item, ) -> <<Or<(F0, F1, F2)> as WorldQueryGats<'wshort>>::Fetch as Fetch<'wshort>>::Item

where 'wlong: 'wshort,

This function manually implements variance for the query items.

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

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

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

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

fn shrink<'wlong, 'wshort>( item: <<Or<(F0, F1, F2, F3)> as WorldQueryGats<'wlong>>::Fetch as Fetch<'wlong>>::Item, ) -> <<Or<(F0, F1, F2, F3)> as WorldQueryGats<'wshort>>::Fetch as Fetch<'wshort>>::Item

where 'wlong: 'wshort,

This function manually implements variance for the query items.

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

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

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

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

fn shrink<'wlong, 'wshort>( item: <<Or<(F0, F1, F2, F3, F4)> as WorldQueryGats<'wlong>>::Fetch as Fetch<'wlong>>::Item, ) -> <<Or<(F0, F1, F2, F3, F4)> as WorldQueryGats<'wshort>>::Fetch as Fetch<'wshort>>::Item

where 'wlong: 'wshort,

This function manually implements variance for the query items.

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

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

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

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

fn shrink<'wlong, 'wshort>( item: <<Or<(F0, F1, F2, F3, F4, F5)> as WorldQueryGats<'wlong>>::Fetch as Fetch<'wlong>>::Item, ) -> <<Or<(F0, F1, F2, F3, F4, F5)> as WorldQueryGats<'wshort>>::Fetch as Fetch<'wshort>>::Item

where 'wlong: 'wshort,

This function manually implements variance for the query items.

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

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

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

type State = Or<(<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)>

fn shrink<'wlong, 'wshort>( item: <<Or<(F0, F1, F2, F3, F4, F5, F6)> as WorldQueryGats<'wlong>>::Fetch as Fetch<'wlong>>::Item, ) -> <<Or<(F0, F1, F2, F3, F4, F5, F6)> as WorldQueryGats<'wshort>>::Fetch as Fetch<'wshort>>::Item

where 'wlong: 'wshort,

This function manually implements variance for the query items.

impl<F0, F1, F2, F3, F4, F5, F6, F7> WorldQuery for Or<(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,

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

type State = Or<(<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)>

fn shrink<'wlong, 'wshort>( item: <<Or<(F0, F1, F2, F3, F4, F5, F6, F7)> as WorldQueryGats<'wlong>>::Fetch as Fetch<'wlong>>::Item, ) -> <<Or<(F0, F1, F2, F3, F4, F5, F6, F7)> as WorldQueryGats<'wshort>>::Fetch as Fetch<'wshort>>::Item

where 'wlong: 'wshort,

This function manually implements variance for the query items.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8> WorldQuery for Or<(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,

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

type State = Or<(<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)>

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

where 'wlong: 'wshort,

This function manually implements variance for the query items.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> WorldQuery for Or<(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,

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

type State = Or<(<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)>

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

where 'wlong: 'wshort,

This function manually implements variance for the query items.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> WorldQuery for Or<(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,

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

type State = Or<(<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)>

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

where 'wlong: 'wshort,

This function manually implements variance for the query items.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> WorldQuery for Or<(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,

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

type State = Or<(<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)>

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

where 'wlong: 'wshort,

This function manually implements variance for the query items.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12> WorldQuery for Or<(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,

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

type State = Or<(<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)>

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

where 'wlong: 'wshort,

This function manually implements variance for the query items.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13> WorldQuery for Or<(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,

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

type State = Or<(<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)>

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

where 'wlong: 'wshort,

This function manually implements variance for the query items.

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14> WorldQuery for Or<(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,

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

type State = Or<(<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)>

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

where 'wlong: 'wshort,

This function manually implements variance for the query items.

impl<'w> WorldQueryGats<'w> for Or<()>

type Fetch = Or<()>

type _State = Or<()>

impl<'w, F0> WorldQueryGats<'w> for Or<(F0,)>

where F0: WorldQueryGats<'w>,

type Fetch = Or<(OrFetch<'w, <F0 as WorldQueryGats<'w>>::Fetch>,)>

type _State = Or<(<F0 as WorldQueryGats<'w>>::_State,)>

impl<'w, F0, F1> WorldQueryGats<'w> for Or<(F0, F1)>

where F0: WorldQueryGats<'w>, F1: WorldQueryGats<'w>,

type Fetch = Or<(OrFetch<'w, <F0 as WorldQueryGats<'w>>::Fetch>, OrFetch<'w, <F1 as WorldQueryGats<'w>>::Fetch>)>

type _State = Or<(<F0 as WorldQueryGats<'w>>::_State, <F1 as WorldQueryGats<'w>>::_State)>

impl<'w, F0, F1, F2> WorldQueryGats<'w> for Or<(F0, F1, F2)>

where F0: WorldQueryGats<'w>, F1: WorldQueryGats<'w>, F2: WorldQueryGats<'w>,

type Fetch = Or<(OrFetch<'w, <F0 as WorldQueryGats<'w>>::Fetch>, OrFetch<'w, <F1 as WorldQueryGats<'w>>::Fetch>, OrFetch<'w, <F2 as WorldQueryGats<'w>>::Fetch>)>

type _State = Or<(<F0 as WorldQueryGats<'w>>::_State, <F1 as WorldQueryGats<'w>>::_State, <F2 as WorldQueryGats<'w>>::_State)>

impl<'w, F0, F1, F2, F3> WorldQueryGats<'w> for Or<(F0, F1, F2, F3)>

where F0: WorldQueryGats<'w>, F1: WorldQueryGats<'w>, F2: WorldQueryGats<'w>, F3: WorldQueryGats<'w>,

type Fetch = Or<(OrFetch<'w, <F0 as WorldQueryGats<'w>>::Fetch>, OrFetch<'w, <F1 as WorldQueryGats<'w>>::Fetch>, OrFetch<'w, <F2 as WorldQueryGats<'w>>::Fetch>, OrFetch<'w, <F3 as WorldQueryGats<'w>>::Fetch>)>

type _State = Or<(<F0 as WorldQueryGats<'w>>::_State, <F1 as WorldQueryGats<'w>>::_State, <F2 as WorldQueryGats<'w>>::_State, <F3 as WorldQueryGats<'w>>::_State)>

impl<'w, F0, F1, F2, F3, F4> WorldQueryGats<'w> for Or<(F0, F1, F2, F3, F4)>

where F0: WorldQueryGats<'w>, F1: WorldQueryGats<'w>, F2: WorldQueryGats<'w>, F3: WorldQueryGats<'w>, F4: WorldQueryGats<'w>,

type Fetch = Or<(OrFetch<'w, <F0 as WorldQueryGats<'w>>::Fetch>, OrFetch<'w, <F1 as WorldQueryGats<'w>>::Fetch>, OrFetch<'w, <F2 as WorldQueryGats<'w>>::Fetch>, OrFetch<'w, <F3 as WorldQueryGats<'w>>::Fetch>, OrFetch<'w, <F4 as WorldQueryGats<'w>>::Fetch>)>

type _State = Or<(<F0 as WorldQueryGats<'w>>::_State, <F1 as WorldQueryGats<'w>>::_State, <F2 as WorldQueryGats<'w>>::_State, <F3 as WorldQueryGats<'w>>::_State, <F4 as WorldQueryGats<'w>>::_State)>

impl<'w, F0, F1, F2, F3, F4, F5> WorldQueryGats<'w> for Or<(F0, F1, F2, F3, F4, F5)>

where F0: WorldQueryGats<'w>, F1: WorldQueryGats<'w>, F2: WorldQueryGats<'w>, F3: WorldQueryGats<'w>, F4: WorldQueryGats<'w>, F5: WorldQueryGats<'w>,

type Fetch = Or<(OrFetch<'w, <F0 as WorldQueryGats<'w>>::Fetch>, OrFetch<'w, <F1 as WorldQueryGats<'w>>::Fetch>, OrFetch<'w, <F2 as WorldQueryGats<'w>>::Fetch>, OrFetch<'w, <F3 as WorldQueryGats<'w>>::Fetch>, OrFetch<'w, <F4 as WorldQueryGats<'w>>::Fetch>, OrFetch<'w, <F5 as WorldQueryGats<'w>>::Fetch>)>

type _State = Or<(<F0 as WorldQueryGats<'w>>::_State, <F1 as WorldQueryGats<'w>>::_State, <F2 as WorldQueryGats<'w>>::_State, <F3 as WorldQueryGats<'w>>::_State, <F4 as WorldQueryGats<'w>>::_State, <F5 as WorldQueryGats<'w>>::_State)>

impl<'w, F0, F1, F2, F3, F4, F5, F6> WorldQueryGats<'w> for Or<(F0, F1, F2, F3, F4, F5, F6)>

where F0: WorldQueryGats<'w>, F1: WorldQueryGats<'w>, F2: WorldQueryGats<'w>, F3: WorldQueryGats<'w>, F4: WorldQueryGats<'w>, F5: WorldQueryGats<'w>, F6: WorldQueryGats<'w>,

type Fetch = Or<(OrFetch<'w, <F0 as WorldQueryGats<'w>>::Fetch>, OrFetch<'w, <F1 as WorldQueryGats<'w>>::Fetch>, OrFetch<'w, <F2 as WorldQueryGats<'w>>::Fetch>, OrFetch<'w, <F3 as WorldQueryGats<'w>>::Fetch>, OrFetch<'w, <F4 as WorldQueryGats<'w>>::Fetch>, OrFetch<'w, <F5 as WorldQueryGats<'w>>::Fetch>, OrFetch<'w, <F6 as WorldQueryGats<'w>>::Fetch>)>

type _State = Or<(<F0 as WorldQueryGats<'w>>::_State, <F1 as WorldQueryGats<'w>>::_State, <F2 as WorldQueryGats<'w>>::_State, <F3 as WorldQueryGats<'w>>::_State, <F4 as WorldQueryGats<'w>>::_State, <F5 as WorldQueryGats<'w>>::_State, <F6 as WorldQueryGats<'w>>::_State)>

impl<'w, F0, F1, F2, F3, F4, F5, F6, F7> WorldQueryGats<'w> for Or<(F0, F1, F2, F3, F4, F5, F6, F7)>

where F0: WorldQueryGats<'w>, F1: WorldQueryGats<'w>, F2: WorldQueryGats<'w>, F3: WorldQueryGats<'w>, F4: WorldQueryGats<'w>, F5: WorldQueryGats<'w>, F6: WorldQueryGats<'w>, F7: WorldQueryGats<'w>,

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

type _State = Or<(<F0 as WorldQueryGats<'w>>::_State, <F1 as WorldQueryGats<'w>>::_State, <F2 as WorldQueryGats<'w>>::_State, <F3 as WorldQueryGats<'w>>::_State, <F4 as WorldQueryGats<'w>>::_State, <F5 as WorldQueryGats<'w>>::_State, <F6 as WorldQueryGats<'w>>::_State, <F7 as WorldQueryGats<'w>>::_State)>

impl<'w, F0, F1, F2, F3, F4, F5, F6, F7, F8> WorldQueryGats<'w> for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8)>

where F0: WorldQueryGats<'w>, F1: WorldQueryGats<'w>, F2: WorldQueryGats<'w>, F3: WorldQueryGats<'w>, F4: WorldQueryGats<'w>, F5: WorldQueryGats<'w>, F6: WorldQueryGats<'w>, F7: WorldQueryGats<'w>, F8: WorldQueryGats<'w>,

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

type _State = Or<(<F0 as WorldQueryGats<'w>>::_State, <F1 as WorldQueryGats<'w>>::_State, <F2 as WorldQueryGats<'w>>::_State, <F3 as WorldQueryGats<'w>>::_State, <F4 as WorldQueryGats<'w>>::_State, <F5 as WorldQueryGats<'w>>::_State, <F6 as WorldQueryGats<'w>>::_State, <F7 as WorldQueryGats<'w>>::_State, <F8 as WorldQueryGats<'w>>::_State)>

impl<'w, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> WorldQueryGats<'w> for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)>

where F0: WorldQueryGats<'w>, F1: WorldQueryGats<'w>, F2: WorldQueryGats<'w>, F3: WorldQueryGats<'w>, F4: WorldQueryGats<'w>, F5: WorldQueryGats<'w>, F6: WorldQueryGats<'w>, F7: WorldQueryGats<'w>, F8: WorldQueryGats<'w>, F9: WorldQueryGats<'w>,

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

type _State = Or<(<F0 as WorldQueryGats<'w>>::_State, <F1 as WorldQueryGats<'w>>::_State, <F2 as WorldQueryGats<'w>>::_State, <F3 as WorldQueryGats<'w>>::_State, <F4 as WorldQueryGats<'w>>::_State, <F5 as WorldQueryGats<'w>>::_State, <F6 as WorldQueryGats<'w>>::_State, <F7 as WorldQueryGats<'w>>::_State, <F8 as WorldQueryGats<'w>>::_State, <F9 as WorldQueryGats<'w>>::_State)>

impl<'w, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> WorldQueryGats<'w> for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)>

where F0: WorldQueryGats<'w>, F1: WorldQueryGats<'w>, F2: WorldQueryGats<'w>, F3: WorldQueryGats<'w>, F4: WorldQueryGats<'w>, F5: WorldQueryGats<'w>, F6: WorldQueryGats<'w>, F7: WorldQueryGats<'w>, F8: WorldQueryGats<'w>, F9: WorldQueryGats<'w>, F10: WorldQueryGats<'w>,

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

type _State = Or<(<F0 as WorldQueryGats<'w>>::_State, <F1 as WorldQueryGats<'w>>::_State, <F2 as WorldQueryGats<'w>>::_State, <F3 as WorldQueryGats<'w>>::_State, <F4 as WorldQueryGats<'w>>::_State, <F5 as WorldQueryGats<'w>>::_State, <F6 as WorldQueryGats<'w>>::_State, <F7 as WorldQueryGats<'w>>::_State, <F8 as WorldQueryGats<'w>>::_State, <F9 as WorldQueryGats<'w>>::_State, <F10 as WorldQueryGats<'w>>::_State)>

impl<'w, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> WorldQueryGats<'w> for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)>

where F0: WorldQueryGats<'w>, F1: WorldQueryGats<'w>, F2: WorldQueryGats<'w>, F3: WorldQueryGats<'w>, F4: WorldQueryGats<'w>, F5: WorldQueryGats<'w>, F6: WorldQueryGats<'w>, F7: WorldQueryGats<'w>, F8: WorldQueryGats<'w>, F9: WorldQueryGats<'w>, F10: WorldQueryGats<'w>, F11: WorldQueryGats<'w>,

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

type _State = Or<(<F0 as WorldQueryGats<'w>>::_State, <F1 as WorldQueryGats<'w>>::_State, <F2 as WorldQueryGats<'w>>::_State, <F3 as WorldQueryGats<'w>>::_State, <F4 as WorldQueryGats<'w>>::_State, <F5 as WorldQueryGats<'w>>::_State, <F6 as WorldQueryGats<'w>>::_State, <F7 as WorldQueryGats<'w>>::_State, <F8 as WorldQueryGats<'w>>::_State, <F9 as WorldQueryGats<'w>>::_State, <F10 as WorldQueryGats<'w>>::_State, <F11 as WorldQueryGats<'w>>::_State)>

impl<'w, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12> WorldQueryGats<'w> for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)>

where F0: WorldQueryGats<'w>, F1: WorldQueryGats<'w>, F2: WorldQueryGats<'w>, F3: WorldQueryGats<'w>, F4: WorldQueryGats<'w>, F5: WorldQueryGats<'w>, F6: WorldQueryGats<'w>, F7: WorldQueryGats<'w>, F8: WorldQueryGats<'w>, F9: WorldQueryGats<'w>, F10: WorldQueryGats<'w>, F11: WorldQueryGats<'w>, F12: WorldQueryGats<'w>,

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

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

impl<'w, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13> WorldQueryGats<'w> for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)>

where F0: WorldQueryGats<'w>, F1: WorldQueryGats<'w>, F2: WorldQueryGats<'w>, F3: WorldQueryGats<'w>, F4: WorldQueryGats<'w>, F5: WorldQueryGats<'w>, F6: WorldQueryGats<'w>, F7: WorldQueryGats<'w>, F8: WorldQueryGats<'w>, F9: WorldQueryGats<'w>, F10: WorldQueryGats<'w>, F11: WorldQueryGats<'w>, F12: WorldQueryGats<'w>, F13: WorldQueryGats<'w>,

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

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

impl<'w, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14> WorldQueryGats<'w> for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)>

where F0: WorldQueryGats<'w>, F1: WorldQueryGats<'w>, F2: WorldQueryGats<'w>, F3: WorldQueryGats<'w>, F4: WorldQueryGats<'w>, F5: WorldQueryGats<'w>, F6: WorldQueryGats<'w>, F7: WorldQueryGats<'w>, F8: WorldQueryGats<'w>, F9: WorldQueryGats<'w>, F10: WorldQueryGats<'w>, F11: WorldQueryGats<'w>, F12: WorldQueryGats<'w>, F13: WorldQueryGats<'w>, F14: WorldQueryGats<'w>,

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

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

impl ArchetypeFilter for Or<()>

impl<F0> ArchetypeFilter for Or<(F0,)>

where F0: ArchetypeFilter,

impl<F0, F1> ArchetypeFilter for Or<(F0, F1)>

where F0: ArchetypeFilter, F1: ArchetypeFilter,

impl<F0, F1, F2> ArchetypeFilter for Or<(F0, F1, F2)>

where F0: ArchetypeFilter, F1: ArchetypeFilter, F2: ArchetypeFilter,

impl<F0, F1, F2, F3> ArchetypeFilter for Or<(F0, F1, F2, F3)>

where F0: ArchetypeFilter, F1: ArchetypeFilter, F2: ArchetypeFilter, F3: ArchetypeFilter,

impl<F0, F1, F2, F3, F4> ArchetypeFilter for Or<(F0, F1, F2, F3, F4)>

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

impl<F0, F1, F2, F3, F4, F5> ArchetypeFilter for Or<(F0, F1, F2, F3, F4, F5)>

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

impl<F0, F1, F2, F3, F4, F5, F6> ArchetypeFilter for Or<(F0, F1, F2, F3, F4, F5, F6)>

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

impl<F0, F1, F2, F3, F4, F5, F6, F7> ArchetypeFilter for Or<(F0, F1, F2, F3, F4, F5, F6, F7)>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<T> Copy for Or<T>

where T: Copy,

impl ReadOnlyWorldQuery for Or<()>

impl<F0> ReadOnlyWorldQuery for Or<(F0,)>

where F0: ReadOnlyWorldQuery,

impl<F0, F1> ReadOnlyWorldQuery for Or<(F0, F1)>

where F0: ReadOnlyWorldQuery, F1: ReadOnlyWorldQuery,

impl<F0, F1, F2> ReadOnlyWorldQuery for Or<(F0, F1, F2)>

where F0: ReadOnlyWorldQuery, F1: ReadOnlyWorldQuery, F2: ReadOnlyWorldQuery,

impl<F0, F1, F2, F3> ReadOnlyWorldQuery for Or<(F0, F1, F2, F3)>

where F0: ReadOnlyWorldQuery, F1: ReadOnlyWorldQuery, F2: ReadOnlyWorldQuery, F3: ReadOnlyWorldQuery,

impl<F0, F1, F2, F3, F4> ReadOnlyWorldQuery for Or<(F0, F1, F2, F3, F4)>

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

impl<F0, F1, F2, F3, F4, F5> ReadOnlyWorldQuery for Or<(F0, F1, F2, F3, F4, F5)>

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

impl<F0, F1, F2, F3, F4, F5, F6> ReadOnlyWorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6)>

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

impl<F0, F1, F2, F3, F4, F5, F6, F7> ReadOnlyWorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7)>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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