Struct bevy_ecs::query::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.iter() {
        println!("Entity {:?} got a new style or color", entity);
    }
}

Tuple Fields

0: T

Trait Implementations

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

type State = Or<()>

type Item = bool

unsafe fn init(
    world: &World,
    state: &Self::State,
    last_change_tick: u32,
    change_tick: u32
) -> Self

Creates a new instance of this fetch.

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.

unsafe fn set_table(&mut self, state: &Self::State, table: &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: &Self::State,
    archetype: &Archetype,
    tables: &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

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

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

type Item = bool

unsafe fn init(
    world: &World,
    state: &Self::State,
    last_change_tick: u32,
    change_tick: u32
) -> Self

Creates a new instance of this fetch.

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.

unsafe fn set_table(&mut self, state: &Self::State, table: &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: &Self::State,
    archetype: &Archetype,
    tables: &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

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

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

type Item = bool

unsafe fn init(
    world: &World,
    state: &Self::State,
    last_change_tick: u32,
    change_tick: u32
) -> Self

Creates a new instance of this fetch.

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.

unsafe fn set_table(&mut self, state: &Self::State, table: &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: &Self::State,
    archetype: &Archetype,
    tables: &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

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

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

type Item = bool

unsafe fn init(
    world: &World,
    state: &Self::State,
    last_change_tick: u32,
    change_tick: u32
) -> Self

Creates a new instance of this fetch.

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.

unsafe fn set_table(&mut self, state: &Self::State, table: &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: &Self::State,
    archetype: &Archetype,
    tables: &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

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

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

type Item = bool

unsafe fn init(
    world: &World,
    state: &Self::State,
    last_change_tick: u32,
    change_tick: u32
) -> Self

Creates a new instance of this fetch.

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.

unsafe fn set_table(&mut self, state: &Self::State, table: &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: &Self::State,
    archetype: &Archetype,
    tables: &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

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

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

type Item = bool

unsafe fn init(
    world: &World,
    state: &Self::State,
    last_change_tick: u32,
    change_tick: u32
) -> Self

Creates a new instance of this fetch.

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.

unsafe fn set_table(&mut self, state: &Self::State, table: &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: &Self::State,
    archetype: &Archetype,
    tables: &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

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

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

type Item = bool

unsafe fn init(
    world: &World,
    state: &Self::State,
    last_change_tick: u32,
    change_tick: u32
) -> Self

Creates a new instance of this fetch.

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.

unsafe fn set_table(&mut self, state: &Self::State, table: &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: &Self::State,
    archetype: &Archetype,
    tables: &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

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

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

type Item = bool

unsafe fn init(
    world: &World,
    state: &Self::State,
    last_change_tick: u32,
    change_tick: u32
) -> Self

Creates a new instance of this fetch.

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.

unsafe fn set_table(&mut self, state: &Self::State, table: &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: &Self::State,
    archetype: &Archetype,
    tables: &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

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

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

type Item = bool

unsafe fn init(
    world: &World,
    state: &Self::State,
    last_change_tick: u32,
    change_tick: u32
) -> Self

Creates a new instance of this fetch.

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.

unsafe fn set_table(&mut self, state: &Self::State, table: &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: &Self::State,
    archetype: &Archetype,
    tables: &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

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

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

type Item = bool

unsafe fn init(
    world: &World,
    state: &Self::State,
    last_change_tick: u32,
    change_tick: u32
) -> Self

Creates a new instance of this fetch.

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.

unsafe fn set_table(&mut self, state: &Self::State, table: &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: &Self::State,
    archetype: &Archetype,
    tables: &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

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

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

type Item = bool

unsafe fn init(
    world: &World,
    state: &Self::State,
    last_change_tick: u32,
    change_tick: u32
) -> Self

Creates a new instance of this fetch.

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.

unsafe fn set_table(&mut self, state: &Self::State, table: &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: &Self::State,
    archetype: &Archetype,
    tables: &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

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

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

type Item = bool

unsafe fn init(
    world: &World,
    state: &Self::State,
    last_change_tick: u32,
    change_tick: u32
) -> Self

Creates a new instance of this fetch.

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.

unsafe fn set_table(&mut self, state: &Self::State, table: &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: &Self::State,
    archetype: &Archetype,
    tables: &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

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

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

type Item = bool

unsafe fn init(
    world: &World,
    state: &Self::State,
    last_change_tick: u32,
    change_tick: u32
) -> Self

Creates a new instance of this fetch.

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.

unsafe fn set_table(&mut self, state: &Self::State, table: &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: &Self::State,
    archetype: &Archetype,
    tables: &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

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

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

type Item = bool

unsafe fn init(
    world: &World,
    state: &Self::State,
    last_change_tick: u32,
    change_tick: u32
) -> Self

Creates a new instance of this fetch.

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.

unsafe fn set_table(&mut self, state: &Self::State, table: &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: &Self::State,
    archetype: &Archetype,
    tables: &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

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

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

type Item = bool

unsafe fn init(
    world: &World,
    state: &Self::State,
    last_change_tick: u32,
    change_tick: u32
) -> Self

Creates a new instance of this fetch.

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.

unsafe fn set_table(&mut self, state: &Self::State, table: &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: &Self::State,
    archetype: &Archetype,
    tables: &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

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

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

type Item = bool

unsafe fn init(
    world: &World,
    state: &Self::State,
    last_change_tick: u32,
    change_tick: u32
) -> Self

Creates a new instance of this fetch.

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.

unsafe fn set_table(&mut self, state: &Self::State, table: &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: &Self::State,
    archetype: &Archetype,
    tables: &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

impl FetchState for Or<()>

fn init(world: &mut World) -> Self

fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>)

fn update_archetype_component_access(
    &self,
    archetype: &Archetype,
    access: &mut Access<ArchetypeComponentId>
)

fn matches_archetype(&self, archetype: &Archetype) -> bool

fn matches_table(&self, table: &Table) -> bool

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

fn init(world: &mut World) -> Self

fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>)

fn update_archetype_component_access(
    &self,
    archetype: &Archetype,
    access: &mut Access<ArchetypeComponentId>
)

fn matches_archetype(&self, archetype: &Archetype) -> bool

fn matches_table(&self, table: &Table) -> bool

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

fn init(world: &mut World) -> Self

fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>)

fn update_archetype_component_access(
    &self,
    archetype: &Archetype,
    access: &mut Access<ArchetypeComponentId>
)

fn matches_archetype(&self, archetype: &Archetype) -> bool

fn matches_table(&self, table: &Table) -> bool

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

fn init(world: &mut World) -> Self

fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>)

fn update_archetype_component_access(
    &self,
    archetype: &Archetype,
    access: &mut Access<ArchetypeComponentId>
)

fn matches_archetype(&self, archetype: &Archetype) -> bool

fn matches_table(&self, table: &Table) -> bool

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

fn init(world: &mut World) -> Self

fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>)

fn update_archetype_component_access(
    &self,
    archetype: &Archetype,
    access: &mut Access<ArchetypeComponentId>
)

fn matches_archetype(&self, archetype: &Archetype) -> bool

fn matches_table(&self, table: &Table) -> bool

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

fn init(world: &mut World) -> Self

fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>)

fn update_archetype_component_access(
    &self,
    archetype: &Archetype,
    access: &mut Access<ArchetypeComponentId>
)

fn matches_archetype(&self, archetype: &Archetype) -> bool

fn matches_table(&self, table: &Table) -> bool

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

fn init(world: &mut World) -> Self

fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>)

fn update_archetype_component_access(
    &self,
    archetype: &Archetype,
    access: &mut Access<ArchetypeComponentId>
)

fn matches_archetype(&self, archetype: &Archetype) -> bool

fn matches_table(&self, table: &Table) -> bool

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

fn init(world: &mut World) -> Self

fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>)

fn update_archetype_component_access(
    &self,
    archetype: &Archetype,
    access: &mut Access<ArchetypeComponentId>
)

fn matches_archetype(&self, archetype: &Archetype) -> bool

fn matches_table(&self, table: &Table) -> bool

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

fn init(world: &mut World) -> Self

fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>)

fn update_archetype_component_access(
    &self,
    archetype: &Archetype,
    access: &mut Access<ArchetypeComponentId>
)

fn matches_archetype(&self, archetype: &Archetype) -> bool

fn matches_table(&self, table: &Table) -> bool

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

fn init(world: &mut World) -> Self

fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>)

fn update_archetype_component_access(
    &self,
    archetype: &Archetype,
    access: &mut Access<ArchetypeComponentId>
)

fn matches_archetype(&self, archetype: &Archetype) -> bool

fn matches_table(&self, table: &Table) -> bool

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

fn init(world: &mut World) -> Self

fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>)

fn update_archetype_component_access(
    &self,
    archetype: &Archetype,
    access: &mut Access<ArchetypeComponentId>
)

fn matches_archetype(&self, archetype: &Archetype) -> bool

fn matches_table(&self, table: &Table) -> bool

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

fn init(world: &mut World) -> Self

fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>)

fn update_archetype_component_access(
    &self,
    archetype: &Archetype,
    access: &mut Access<ArchetypeComponentId>
)

fn matches_archetype(&self, archetype: &Archetype) -> bool

fn matches_table(&self, table: &Table) -> bool

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

fn init(world: &mut World) -> Self

fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>)

fn update_archetype_component_access(
    &self,
    archetype: &Archetype,
    access: &mut Access<ArchetypeComponentId>
)

fn matches_archetype(&self, archetype: &Archetype) -> bool

fn matches_table(&self, table: &Table) -> bool

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

fn init(world: &mut World) -> Self

fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>)

fn update_archetype_component_access(
    &self,
    archetype: &Archetype,
    access: &mut Access<ArchetypeComponentId>
)

fn matches_archetype(&self, archetype: &Archetype) -> bool

fn matches_table(&self, table: &Table) -> bool

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

fn init(world: &mut World) -> Self

fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>)

fn update_archetype_component_access(
    &self,
    archetype: &Archetype,
    access: &mut Access<ArchetypeComponentId>
)

fn matches_archetype(&self, archetype: &Archetype) -> bool

fn matches_table(&self, table: &Table) -> bool

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

fn init(world: &mut World) -> Self

fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>)

fn update_archetype_component_access(
    &self,
    archetype: &Archetype,
    access: &mut Access<ArchetypeComponentId>
)

fn matches_archetype(&self, archetype: &Archetype) -> bool

fn matches_table(&self, table: &Table) -> bool

impl WorldQuery for Or<()>

type Fetch = Or<()>

type State = Or<()>

type ReadOnlyFetch = Or<()>

impl<F0: WorldQuery> WorldQuery for Or<(F0,)> where
    F0::Fetch: FilterFetch,
    F0::ReadOnlyFetch: FilterFetch, 

type Fetch = Or<(OrFetch<F0::Fetch>,)>

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

type ReadOnlyFetch = Or<(OrFetch<F0::ReadOnlyFetch>,)>

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)> where
    F0::Fetch: FilterFetch,
    F0::ReadOnlyFetch: FilterFetch,
    F1::Fetch: FilterFetch,
    F1::ReadOnlyFetch: FilterFetch,
    F2::Fetch: FilterFetch,
    F2::ReadOnlyFetch: FilterFetch,
    F3::Fetch: FilterFetch,
    F3::ReadOnlyFetch: FilterFetch,
    F4::Fetch: FilterFetch,
    F4::ReadOnlyFetch: FilterFetch,
    F5::Fetch: FilterFetch,
    F5::ReadOnlyFetch: FilterFetch,
    F6::Fetch: FilterFetch,
    F6::ReadOnlyFetch: FilterFetch,
    F7::Fetch: FilterFetch,
    F7::ReadOnlyFetch: FilterFetch,
    F8::Fetch: FilterFetch,
    F8::ReadOnlyFetch: FilterFetch,
    F9::Fetch: FilterFetch,
    F9::ReadOnlyFetch: FilterFetch, 

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

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

type ReadOnlyFetch = Or<(OrFetch<F0::ReadOnlyFetch>, OrFetch<F1::ReadOnlyFetch>, OrFetch<F2::ReadOnlyFetch>, OrFetch<F3::ReadOnlyFetch>, OrFetch<F4::ReadOnlyFetch>, OrFetch<F5::ReadOnlyFetch>, OrFetch<F6::ReadOnlyFetch>, OrFetch<F7::ReadOnlyFetch>, OrFetch<F8::ReadOnlyFetch>, OrFetch<F9::ReadOnlyFetch>)>

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> where
    F0::Fetch: FilterFetch,
    F0::ReadOnlyFetch: FilterFetch,
    F1::Fetch: FilterFetch,
    F1::ReadOnlyFetch: FilterFetch,
    F2::Fetch: FilterFetch,
    F2::ReadOnlyFetch: FilterFetch,
    F3::Fetch: FilterFetch,
    F3::ReadOnlyFetch: FilterFetch,
    F4::Fetch: FilterFetch,
    F4::ReadOnlyFetch: FilterFetch,
    F5::Fetch: FilterFetch,
    F5::ReadOnlyFetch: FilterFetch,
    F6::Fetch: FilterFetch,
    F6::ReadOnlyFetch: FilterFetch,
    F7::Fetch: FilterFetch,
    F7::ReadOnlyFetch: FilterFetch,
    F8::Fetch: FilterFetch,
    F8::ReadOnlyFetch: FilterFetch,
    F9::Fetch: FilterFetch,
    F9::ReadOnlyFetch: FilterFetch,
    F10::Fetch: FilterFetch,
    F10::ReadOnlyFetch: FilterFetch, 

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

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

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

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery, F11: WorldQuery> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> where
    F0::Fetch: FilterFetch,
    F0::ReadOnlyFetch: FilterFetch,
    F1::Fetch: FilterFetch,
    F1::ReadOnlyFetch: FilterFetch,
    F2::Fetch: FilterFetch,
    F2::ReadOnlyFetch: FilterFetch,
    F3::Fetch: FilterFetch,
    F3::ReadOnlyFetch: FilterFetch,
    F4::Fetch: FilterFetch,
    F4::ReadOnlyFetch: FilterFetch,
    F5::Fetch: FilterFetch,
    F5::ReadOnlyFetch: FilterFetch,
    F6::Fetch: FilterFetch,
    F6::ReadOnlyFetch: FilterFetch,
    F7::Fetch: FilterFetch,
    F7::ReadOnlyFetch: FilterFetch,
    F8::Fetch: FilterFetch,
    F8::ReadOnlyFetch: FilterFetch,
    F9::Fetch: FilterFetch,
    F9::ReadOnlyFetch: FilterFetch,
    F10::Fetch: FilterFetch,
    F10::ReadOnlyFetch: FilterFetch,
    F11::Fetch: FilterFetch,
    F11::ReadOnlyFetch: FilterFetch, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<F0: WorldQuery, F1: WorldQuery> WorldQuery for Or<(F0, F1)> where
    F0::Fetch: FilterFetch,
    F0::ReadOnlyFetch: FilterFetch,
    F1::Fetch: FilterFetch,
    F1::ReadOnlyFetch: FilterFetch, 

type Fetch = Or<(OrFetch<F0::Fetch>, OrFetch<F1::Fetch>)>

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

type ReadOnlyFetch = Or<(OrFetch<F0::ReadOnlyFetch>, OrFetch<F1::ReadOnlyFetch>)>

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery> WorldQuery for Or<(F0, F1, F2)> where
    F0::Fetch: FilterFetch,
    F0::ReadOnlyFetch: FilterFetch,
    F1::Fetch: FilterFetch,
    F1::ReadOnlyFetch: FilterFetch,
    F2::Fetch: FilterFetch,
    F2::ReadOnlyFetch: FilterFetch, 

type Fetch = Or<(OrFetch<F0::Fetch>, OrFetch<F1::Fetch>, OrFetch<F2::Fetch>)>

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

type ReadOnlyFetch = Or<(OrFetch<F0::ReadOnlyFetch>, OrFetch<F1::ReadOnlyFetch>, OrFetch<F2::ReadOnlyFetch>)>

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery> WorldQuery for Or<(F0, F1, F2, F3)> where
    F0::Fetch: FilterFetch,
    F0::ReadOnlyFetch: FilterFetch,
    F1::Fetch: FilterFetch,
    F1::ReadOnlyFetch: FilterFetch,
    F2::Fetch: FilterFetch,
    F2::ReadOnlyFetch: FilterFetch,
    F3::Fetch: FilterFetch,
    F3::ReadOnlyFetch: FilterFetch, 

type Fetch = Or<(OrFetch<F0::Fetch>, OrFetch<F1::Fetch>, OrFetch<F2::Fetch>, OrFetch<F3::Fetch>)>

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

type ReadOnlyFetch = Or<(OrFetch<F0::ReadOnlyFetch>, OrFetch<F1::ReadOnlyFetch>, OrFetch<F2::ReadOnlyFetch>, OrFetch<F3::ReadOnlyFetch>)>

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery> WorldQuery for Or<(F0, F1, F2, F3, F4)> where
    F0::Fetch: FilterFetch,
    F0::ReadOnlyFetch: FilterFetch,
    F1::Fetch: FilterFetch,
    F1::ReadOnlyFetch: FilterFetch,
    F2::Fetch: FilterFetch,
    F2::ReadOnlyFetch: FilterFetch,
    F3::Fetch: FilterFetch,
    F3::ReadOnlyFetch: FilterFetch,
    F4::Fetch: FilterFetch,
    F4::ReadOnlyFetch: FilterFetch, 

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

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

type ReadOnlyFetch = Or<(OrFetch<F0::ReadOnlyFetch>, OrFetch<F1::ReadOnlyFetch>, OrFetch<F2::ReadOnlyFetch>, OrFetch<F3::ReadOnlyFetch>, OrFetch<F4::ReadOnlyFetch>)>

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery> WorldQuery for Or<(F0, F1, F2, F3, F4, F5)> where
    F0::Fetch: FilterFetch,
    F0::ReadOnlyFetch: FilterFetch,
    F1::Fetch: FilterFetch,
    F1::ReadOnlyFetch: FilterFetch,
    F2::Fetch: FilterFetch,
    F2::ReadOnlyFetch: FilterFetch,
    F3::Fetch: FilterFetch,
    F3::ReadOnlyFetch: FilterFetch,
    F4::Fetch: FilterFetch,
    F4::ReadOnlyFetch: FilterFetch,
    F5::Fetch: FilterFetch,
    F5::ReadOnlyFetch: FilterFetch, 

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

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

type ReadOnlyFetch = Or<(OrFetch<F0::ReadOnlyFetch>, OrFetch<F1::ReadOnlyFetch>, OrFetch<F2::ReadOnlyFetch>, OrFetch<F3::ReadOnlyFetch>, OrFetch<F4::ReadOnlyFetch>, OrFetch<F5::ReadOnlyFetch>)>

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6)> where
    F0::Fetch: FilterFetch,
    F0::ReadOnlyFetch: FilterFetch,
    F1::Fetch: FilterFetch,
    F1::ReadOnlyFetch: FilterFetch,
    F2::Fetch: FilterFetch,
    F2::ReadOnlyFetch: FilterFetch,
    F3::Fetch: FilterFetch,
    F3::ReadOnlyFetch: FilterFetch,
    F4::Fetch: FilterFetch,
    F4::ReadOnlyFetch: FilterFetch,
    F5::Fetch: FilterFetch,
    F5::ReadOnlyFetch: FilterFetch,
    F6::Fetch: FilterFetch,
    F6::ReadOnlyFetch: FilterFetch, 

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

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

type ReadOnlyFetch = Or<(OrFetch<F0::ReadOnlyFetch>, OrFetch<F1::ReadOnlyFetch>, OrFetch<F2::ReadOnlyFetch>, OrFetch<F3::ReadOnlyFetch>, OrFetch<F4::ReadOnlyFetch>, OrFetch<F5::ReadOnlyFetch>, OrFetch<F6::ReadOnlyFetch>)>

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7)> where
    F0::Fetch: FilterFetch,
    F0::ReadOnlyFetch: FilterFetch,
    F1::Fetch: FilterFetch,
    F1::ReadOnlyFetch: FilterFetch,
    F2::Fetch: FilterFetch,
    F2::ReadOnlyFetch: FilterFetch,
    F3::Fetch: FilterFetch,
    F3::ReadOnlyFetch: FilterFetch,
    F4::Fetch: FilterFetch,
    F4::ReadOnlyFetch: FilterFetch,
    F5::Fetch: FilterFetch,
    F5::ReadOnlyFetch: FilterFetch,
    F6::Fetch: FilterFetch,
    F6::ReadOnlyFetch: FilterFetch,
    F7::Fetch: FilterFetch,
    F7::ReadOnlyFetch: FilterFetch, 

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

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

type ReadOnlyFetch = Or<(OrFetch<F0::ReadOnlyFetch>, OrFetch<F1::ReadOnlyFetch>, OrFetch<F2::ReadOnlyFetch>, OrFetch<F3::ReadOnlyFetch>, OrFetch<F4::ReadOnlyFetch>, OrFetch<F5::ReadOnlyFetch>, OrFetch<F6::ReadOnlyFetch>, OrFetch<F7::ReadOnlyFetch>)>

impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8)> where
    F0::Fetch: FilterFetch,
    F0::ReadOnlyFetch: FilterFetch,
    F1::Fetch: FilterFetch,
    F1::ReadOnlyFetch: FilterFetch,
    F2::Fetch: FilterFetch,
    F2::ReadOnlyFetch: FilterFetch,
    F3::Fetch: FilterFetch,
    F3::ReadOnlyFetch: FilterFetch,
    F4::Fetch: FilterFetch,
    F4::ReadOnlyFetch: FilterFetch,
    F5::Fetch: FilterFetch,
    F5::ReadOnlyFetch: FilterFetch,
    F6::Fetch: FilterFetch,
    F6::ReadOnlyFetch: FilterFetch,
    F7::Fetch: FilterFetch,
    F7::ReadOnlyFetch: FilterFetch,
    F8::Fetch: FilterFetch,
    F8::ReadOnlyFetch: FilterFetch, 

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

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

type ReadOnlyFetch = Or<(OrFetch<F0::ReadOnlyFetch>, OrFetch<F1::ReadOnlyFetch>, OrFetch<F2::ReadOnlyFetch>, OrFetch<F3::ReadOnlyFetch>, OrFetch<F4::ReadOnlyFetch>, OrFetch<F5::ReadOnlyFetch>, OrFetch<F6::ReadOnlyFetch>, OrFetch<F7::ReadOnlyFetch>, OrFetch<F8::ReadOnlyFetch>)>

impl ReadOnlyFetch for Or<()>

SAFETY: this only works using the filter which doesn’t write

impl<F0: FilterFetch + ReadOnlyFetch> ReadOnlyFetch for Or<(OrFetch<F0>,)>

SAFETY: this only works using the filter which doesn’t write

impl<F0: FilterFetch + ReadOnlyFetch, F1: FilterFetch + ReadOnlyFetch, F2: FilterFetch + ReadOnlyFetch, F3: FilterFetch + ReadOnlyFetch, F4: FilterFetch + ReadOnlyFetch, F5: FilterFetch + ReadOnlyFetch, F6: FilterFetch + ReadOnlyFetch, F7: FilterFetch + ReadOnlyFetch, F8: FilterFetch + ReadOnlyFetch, F9: FilterFetch + ReadOnlyFetch> ReadOnlyFetch for Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>, OrFetch<F4>, OrFetch<F5>, OrFetch<F6>, OrFetch<F7>, OrFetch<F8>, OrFetch<F9>)>

SAFETY: this only works using the filter which doesn’t write

impl<F0: FilterFetch + ReadOnlyFetch, F1: FilterFetch + ReadOnlyFetch, F2: FilterFetch + ReadOnlyFetch, F3: FilterFetch + ReadOnlyFetch, F4: FilterFetch + ReadOnlyFetch, F5: FilterFetch + ReadOnlyFetch, F6: FilterFetch + ReadOnlyFetch, F7: FilterFetch + ReadOnlyFetch, F8: FilterFetch + ReadOnlyFetch, F9: FilterFetch + ReadOnlyFetch, F10: FilterFetch + ReadOnlyFetch> ReadOnlyFetch for Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>, OrFetch<F4>, OrFetch<F5>, OrFetch<F6>, OrFetch<F7>, OrFetch<F8>, OrFetch<F9>, OrFetch<F10>)>

SAFETY: this only works using the filter which doesn’t write

impl<F0: FilterFetch + ReadOnlyFetch, F1: FilterFetch + ReadOnlyFetch, F2: FilterFetch + ReadOnlyFetch, F3: FilterFetch + ReadOnlyFetch, F4: FilterFetch + ReadOnlyFetch, F5: FilterFetch + ReadOnlyFetch, F6: FilterFetch + ReadOnlyFetch, F7: FilterFetch + ReadOnlyFetch, F8: FilterFetch + ReadOnlyFetch, F9: FilterFetch + ReadOnlyFetch, F10: FilterFetch + ReadOnlyFetch, F11: FilterFetch + ReadOnlyFetch> ReadOnlyFetch for Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>, OrFetch<F4>, OrFetch<F5>, OrFetch<F6>, OrFetch<F7>, OrFetch<F8>, OrFetch<F9>, OrFetch<F10>, OrFetch<F11>)>

SAFETY: this only works using the filter which doesn’t write

impl<F0: FilterFetch + ReadOnlyFetch, F1: FilterFetch + ReadOnlyFetch, F2: FilterFetch + ReadOnlyFetch, F3: FilterFetch + ReadOnlyFetch, F4: FilterFetch + ReadOnlyFetch, F5: FilterFetch + ReadOnlyFetch, F6: FilterFetch + ReadOnlyFetch, F7: FilterFetch + ReadOnlyFetch, F8: FilterFetch + ReadOnlyFetch, F9: FilterFetch + ReadOnlyFetch, F10: FilterFetch + ReadOnlyFetch, F11: FilterFetch + ReadOnlyFetch, F12: FilterFetch + ReadOnlyFetch> ReadOnlyFetch for Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>, OrFetch<F4>, OrFetch<F5>, OrFetch<F6>, OrFetch<F7>, OrFetch<F8>, OrFetch<F9>, OrFetch<F10>, OrFetch<F11>, OrFetch<F12>)>

SAFETY: this only works using the filter which doesn’t write

impl<F0: FilterFetch + ReadOnlyFetch, F1: FilterFetch + ReadOnlyFetch, F2: FilterFetch + ReadOnlyFetch, F3: FilterFetch + ReadOnlyFetch, F4: FilterFetch + ReadOnlyFetch, F5: FilterFetch + ReadOnlyFetch, F6: FilterFetch + ReadOnlyFetch, F7: FilterFetch + ReadOnlyFetch, F8: FilterFetch + ReadOnlyFetch, F9: FilterFetch + ReadOnlyFetch, F10: FilterFetch + ReadOnlyFetch, F11: FilterFetch + ReadOnlyFetch, F12: FilterFetch + ReadOnlyFetch, F13: FilterFetch + ReadOnlyFetch> ReadOnlyFetch for Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>, OrFetch<F4>, OrFetch<F5>, OrFetch<F6>, OrFetch<F7>, OrFetch<F8>, OrFetch<F9>, OrFetch<F10>, OrFetch<F11>, OrFetch<F12>, OrFetch<F13>)>

SAFETY: this only works using the filter which doesn’t write

impl<F0: FilterFetch + ReadOnlyFetch, F1: FilterFetch + ReadOnlyFetch, F2: FilterFetch + ReadOnlyFetch, F3: FilterFetch + ReadOnlyFetch, F4: FilterFetch + ReadOnlyFetch, F5: FilterFetch + ReadOnlyFetch, F6: FilterFetch + ReadOnlyFetch, F7: FilterFetch + ReadOnlyFetch, F8: FilterFetch + ReadOnlyFetch, F9: FilterFetch + ReadOnlyFetch, F10: FilterFetch + ReadOnlyFetch, F11: FilterFetch + ReadOnlyFetch, F12: FilterFetch + ReadOnlyFetch, F13: FilterFetch + ReadOnlyFetch, F14: FilterFetch + ReadOnlyFetch> ReadOnlyFetch for Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>, OrFetch<F4>, OrFetch<F5>, OrFetch<F6>, OrFetch<F7>, OrFetch<F8>, OrFetch<F9>, OrFetch<F10>, OrFetch<F11>, OrFetch<F12>, OrFetch<F13>, OrFetch<F14>)>

SAFETY: this only works using the filter which doesn’t write

impl<F0: FilterFetch + ReadOnlyFetch, F1: FilterFetch + ReadOnlyFetch> ReadOnlyFetch for Or<(OrFetch<F0>, OrFetch<F1>)>

SAFETY: this only works using the filter which doesn’t write

impl<F0: FilterFetch + ReadOnlyFetch, F1: FilterFetch + ReadOnlyFetch, F2: FilterFetch + ReadOnlyFetch> ReadOnlyFetch for Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>)>

SAFETY: this only works using the filter which doesn’t write

impl<F0: FilterFetch + ReadOnlyFetch, F1: FilterFetch + ReadOnlyFetch, F2: FilterFetch + ReadOnlyFetch, F3: FilterFetch + ReadOnlyFetch> ReadOnlyFetch for Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>)>

SAFETY: this only works using the filter which doesn’t write

impl<F0: FilterFetch + ReadOnlyFetch, F1: FilterFetch + ReadOnlyFetch, F2: FilterFetch + ReadOnlyFetch, F3: FilterFetch + ReadOnlyFetch, F4: FilterFetch + ReadOnlyFetch> ReadOnlyFetch for Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>, OrFetch<F4>)>

SAFETY: this only works using the filter which doesn’t write

impl<F0: FilterFetch + ReadOnlyFetch, F1: FilterFetch + ReadOnlyFetch, F2: FilterFetch + ReadOnlyFetch, F3: FilterFetch + ReadOnlyFetch, F4: FilterFetch + ReadOnlyFetch, F5: FilterFetch + ReadOnlyFetch> ReadOnlyFetch for Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>, OrFetch<F4>, OrFetch<F5>)>

SAFETY: this only works using the filter which doesn’t write

impl<F0: FilterFetch + ReadOnlyFetch, F1: FilterFetch + ReadOnlyFetch, F2: FilterFetch + ReadOnlyFetch, F3: FilterFetch + ReadOnlyFetch, F4: FilterFetch + ReadOnlyFetch, F5: FilterFetch + ReadOnlyFetch, F6: FilterFetch + ReadOnlyFetch> ReadOnlyFetch for Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>, OrFetch<F4>, OrFetch<F5>, OrFetch<F6>)>

SAFETY: this only works using the filter which doesn’t write

impl<F0: FilterFetch + ReadOnlyFetch, F1: FilterFetch + ReadOnlyFetch, F2: FilterFetch + ReadOnlyFetch, F3: FilterFetch + ReadOnlyFetch, F4: FilterFetch + ReadOnlyFetch, F5: FilterFetch + ReadOnlyFetch, F6: FilterFetch + ReadOnlyFetch, F7: FilterFetch + ReadOnlyFetch> ReadOnlyFetch for Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>, OrFetch<F4>, OrFetch<F5>, OrFetch<F6>, OrFetch<F7>)>

SAFETY: this only works using the filter which doesn’t write

impl<F0: FilterFetch + ReadOnlyFetch, F1: FilterFetch + ReadOnlyFetch, F2: FilterFetch + ReadOnlyFetch, F3: FilterFetch + ReadOnlyFetch, F4: FilterFetch + ReadOnlyFetch, F5: FilterFetch + ReadOnlyFetch, F6: FilterFetch + ReadOnlyFetch, F7: FilterFetch + ReadOnlyFetch, F8: FilterFetch + ReadOnlyFetch> ReadOnlyFetch for Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>, OrFetch<F4>, OrFetch<F5>, OrFetch<F6>, OrFetch<F7>, OrFetch<F8>)>

SAFETY: this only works using the filter which doesn’t write