Struct bevy::prelude::Or

pub struct Or<T>(pub T);

Trait Implementations

impl<'a, F0, F1> Fetch<'a> for Or<(OrFetch<F0>, OrFetch<F1>)> where
    F0: FilterFetch,
    F1: FilterFetch, 

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

type Item = bool

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

Creates a new instance of this fetch.

pub fn is_dense(&self) -> 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

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

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

pub unsafe fn set_archetype(
    &mut self,
    state: &<Or<(OrFetch<F0>, OrFetch<F1>)> as Fetch<'a>>::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

pub 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

pub 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<'a, F0> Fetch<'a> for Or<(OrFetch<F0>,)> where
    F0: FilterFetch, 

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

type Item = bool

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

Creates a new instance of this fetch.

pub fn is_dense(&self) -> 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

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

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

pub unsafe fn set_archetype(
    &mut self,
    state: &<Or<(OrFetch<F0>,)> as Fetch<'a>>::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

pub 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

pub 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<'a, F0, F1, F2, F3, F4> Fetch<'a> for Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>, OrFetch<F4>)> where
    F0: FilterFetch,
    F1: FilterFetch,
    F2: FilterFetch,
    F3: FilterFetch,
    F4: FilterFetch, 

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

type Item = bool

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

Creates a new instance of this fetch.

pub fn is_dense(&self) -> 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

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

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

pub unsafe fn set_archetype(
    &mut self,
    state: &<Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>, OrFetch<F4>)> as Fetch<'a>>::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

pub 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

pub 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<'a, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> Fetch<'a> for Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>, OrFetch<F4>, OrFetch<F5>, OrFetch<F6>, OrFetch<F7>, OrFetch<F8>, OrFetch<F9>)> where
    F0: FilterFetch,
    F1: FilterFetch,
    F2: FilterFetch,
    F3: FilterFetch,
    F4: FilterFetch,
    F5: FilterFetch,
    F6: FilterFetch,
    F7: FilterFetch,
    F8: FilterFetch,
    F9: FilterFetch, 

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

type Item = bool

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

Creates a new instance of this fetch.

pub fn is_dense(&self) -> 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

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

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

pub unsafe fn set_archetype(
    &mut self,
    state: &<Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>, OrFetch<F4>, OrFetch<F5>, OrFetch<F6>, OrFetch<F7>, OrFetch<F8>, OrFetch<F9>)> as Fetch<'a>>::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

pub 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

pub 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<'a, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12> Fetch<'a> 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>)> where
    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, 

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

type Item = bool

pub unsafe fn init(
    world: &World,
    state: &<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>)> as Fetch<'a>>::State,
    last_change_tick: u32,
    change_tick: u32
) -> 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>)>

Creates a new instance of this fetch.

pub fn is_dense(&self) -> 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

pub unsafe fn set_table(
    &mut self,
    state: &<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>)> as Fetch<'a>>::State,
    table: &Table
)

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

pub unsafe fn set_archetype(
    &mut self,
    state: &<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>)> as Fetch<'a>>::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

pub 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

pub 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<'a> Fetch<'a> for Or<()>

type State = Or<()>

type Item = bool

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

Creates a new instance of this fetch.

pub fn is_dense(&self) -> 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

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

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

pub unsafe fn set_archetype(
    &mut self,
    state: &<Or<()> as Fetch<'a>>::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

pub 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

pub 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<'a, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> Fetch<'a> for Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>, OrFetch<F4>, OrFetch<F5>, OrFetch<F6>, OrFetch<F7>, OrFetch<F8>, OrFetch<F9>, OrFetch<F10>)> where
    F0: FilterFetch,
    F1: FilterFetch,
    F2: FilterFetch,
    F3: FilterFetch,
    F4: FilterFetch,
    F5: FilterFetch,
    F6: FilterFetch,
    F7: FilterFetch,
    F8: FilterFetch,
    F9: FilterFetch,
    F10: FilterFetch, 

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

type Item = bool

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

Creates a new instance of this fetch.

pub fn is_dense(&self) -> 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

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

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

pub unsafe fn set_archetype(
    &mut self,
    state: &<Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>, OrFetch<F4>, OrFetch<F5>, OrFetch<F6>, OrFetch<F7>, OrFetch<F8>, OrFetch<F9>, OrFetch<F10>)> as Fetch<'a>>::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

pub 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

pub 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<'a, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13> Fetch<'a> 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>)> where
    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, 

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

type Item = bool

pub unsafe fn init(
    world: &World,
    state: &<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>)> as Fetch<'a>>::State,
    last_change_tick: u32,
    change_tick: u32
) -> 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>)>

Creates a new instance of this fetch.

pub fn is_dense(&self) -> 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

pub unsafe fn set_table(
    &mut self,
    state: &<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>)> as Fetch<'a>>::State,
    table: &Table
)

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

pub unsafe fn set_archetype(
    &mut self,
    state: &<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>)> as Fetch<'a>>::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

pub 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

pub 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<'a, F0, F1, F2, F3> Fetch<'a> for Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>)> where
    F0: FilterFetch,
    F1: FilterFetch,
    F2: FilterFetch,
    F3: FilterFetch, 

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

type Item = bool

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

Creates a new instance of this fetch.

pub fn is_dense(&self) -> 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

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

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

pub unsafe fn set_archetype(
    &mut self,
    state: &<Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>)> as Fetch<'a>>::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

pub 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

pub 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<'a, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14> Fetch<'a> 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>)> where
    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, 

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

type Item = bool

pub unsafe fn init(
    world: &World,
    state: &<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>)> as Fetch<'a>>::State,
    last_change_tick: u32,
    change_tick: u32
) -> 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>)>

Creates a new instance of this fetch.

pub fn is_dense(&self) -> 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

pub unsafe fn set_table(
    &mut self,
    state: &<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>)> as Fetch<'a>>::State,
    table: &Table
)

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

pub unsafe fn set_archetype(
    &mut self,
    state: &<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>)> as Fetch<'a>>::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

pub 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

pub 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<'a, F0, F1, F2, F3, F4, F5, F6, F7> Fetch<'a> for Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>, OrFetch<F4>, OrFetch<F5>, OrFetch<F6>, OrFetch<F7>)> where
    F0: FilterFetch,
    F1: FilterFetch,
    F2: FilterFetch,
    F3: FilterFetch,
    F4: FilterFetch,
    F5: FilterFetch,
    F6: FilterFetch,
    F7: FilterFetch, 

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

type Item = bool

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

Creates a new instance of this fetch.

pub fn is_dense(&self) -> 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

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

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

pub unsafe fn set_archetype(
    &mut self,
    state: &<Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>, OrFetch<F4>, OrFetch<F5>, OrFetch<F6>, OrFetch<F7>)> as Fetch<'a>>::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

pub 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

pub 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<'a, F0, F1, F2, F3, F4, F5, F6, F7, F8> Fetch<'a> for Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>, OrFetch<F4>, OrFetch<F5>, OrFetch<F6>, OrFetch<F7>, OrFetch<F8>)> where
    F0: FilterFetch,
    F1: FilterFetch,
    F2: FilterFetch,
    F3: FilterFetch,
    F4: FilterFetch,
    F5: FilterFetch,
    F6: FilterFetch,
    F7: FilterFetch,
    F8: FilterFetch, 

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

type Item = bool

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

Creates a new instance of this fetch.

pub fn is_dense(&self) -> 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

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

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

pub unsafe fn set_archetype(
    &mut self,
    state: &<Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>, OrFetch<F4>, OrFetch<F5>, OrFetch<F6>, OrFetch<F7>, OrFetch<F8>)> as Fetch<'a>>::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

pub 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

pub 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<'a, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> Fetch<'a> 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>)> where
    F0: FilterFetch,
    F1: FilterFetch,
    F2: FilterFetch,
    F3: FilterFetch,
    F4: FilterFetch,
    F5: FilterFetch,
    F6: FilterFetch,
    F7: FilterFetch,
    F8: FilterFetch,
    F9: FilterFetch,
    F10: FilterFetch,
    F11: FilterFetch, 

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

type Item = bool

pub unsafe fn init(
    world: &World,
    state: &<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>)> as Fetch<'a>>::State,
    last_change_tick: u32,
    change_tick: u32
) -> 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>)>

Creates a new instance of this fetch.

pub fn is_dense(&self) -> 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

pub unsafe fn set_table(
    &mut self,
    state: &<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>)> as Fetch<'a>>::State,
    table: &Table
)

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

pub unsafe fn set_archetype(
    &mut self,
    state: &<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>)> as Fetch<'a>>::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

pub 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

pub 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<'a, F0, F1, F2, F3, F4, F5> Fetch<'a> for Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>, OrFetch<F4>, OrFetch<F5>)> where
    F0: FilterFetch,
    F1: FilterFetch,
    F2: FilterFetch,
    F3: FilterFetch,
    F4: FilterFetch,
    F5: FilterFetch, 

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

type Item = bool

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

Creates a new instance of this fetch.

pub fn is_dense(&self) -> 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

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

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

pub unsafe fn set_archetype(
    &mut self,
    state: &<Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>, OrFetch<F4>, OrFetch<F5>)> as Fetch<'a>>::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

pub 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

pub 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<'a, F0, F1, F2> Fetch<'a> for Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>)> where
    F0: FilterFetch,
    F1: FilterFetch,
    F2: FilterFetch, 

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

type Item = bool

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

Creates a new instance of this fetch.

pub fn is_dense(&self) -> 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

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

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

pub unsafe fn set_archetype(
    &mut self,
    state: &<Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>)> as Fetch<'a>>::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

pub 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

pub 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<'a, F0, F1, F2, F3, F4, F5, F6> Fetch<'a> for Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>, OrFetch<F4>, OrFetch<F5>, OrFetch<F6>)> where
    F0: FilterFetch,
    F1: FilterFetch,
    F2: FilterFetch,
    F3: FilterFetch,
    F4: FilterFetch,
    F5: FilterFetch,
    F6: FilterFetch, 

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

type Item = bool

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

Creates a new instance of this fetch.

pub fn is_dense(&self) -> 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

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

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

pub unsafe fn set_archetype(
    &mut self,
    state: &<Or<(OrFetch<F0>, OrFetch<F1>, OrFetch<F2>, OrFetch<F3>, OrFetch<F4>, OrFetch<F5>, OrFetch<F6>)> as Fetch<'a>>::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

pub 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

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

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

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

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

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

pub fn matches_table(&self, table: &Table) -> 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, 

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

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

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

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

pub fn matches_table(&self, table: &Table) -> 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, 

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

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

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

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

pub fn matches_table(&self, table: &Table) -> 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, 

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

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

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

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

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

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

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

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

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

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

pub fn matches_table(&self, table: &Table) -> 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, 

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

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

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

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

pub fn matches_table(&self, table: &Table) -> 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, 

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

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

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

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

pub fn matches_table(&self, table: &Table) -> 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, 

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

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

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

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

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

impl FetchState for Or<()>

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

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

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

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

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

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

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

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

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

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

pub fn matches_table(&self, table: &Table) -> 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, 

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

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

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

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

pub fn matches_table(&self, table: &Table) -> 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, 

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

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

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

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

pub fn matches_table(&self, table: &Table) -> 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, 

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

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

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

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

pub fn matches_table(&self, table: &Table) -> 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, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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,
    <F0 as WorldQuery>::Fetch: FilterFetch,
    <F1 as WorldQuery>::Fetch: FilterFetch,
    <F2 as WorldQuery>::Fetch: FilterFetch,
    <F3 as WorldQuery>::Fetch: FilterFetch,
    <F4 as WorldQuery>::Fetch: FilterFetch,
    <F5 as WorldQuery>::Fetch: FilterFetch, 

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

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

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,
    <F0 as WorldQuery>::Fetch: FilterFetch,
    <F1 as WorldQuery>::Fetch: FilterFetch,
    <F2 as WorldQuery>::Fetch: FilterFetch,
    <F3 as WorldQuery>::Fetch: FilterFetch,
    <F4 as WorldQuery>::Fetch: FilterFetch, 

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

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

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

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

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

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

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

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

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,
    <F0 as WorldQuery>::Fetch: FilterFetch,
    <F1 as WorldQuery>::Fetch: FilterFetch,
    <F2 as WorldQuery>::Fetch: FilterFetch,
    <F3 as WorldQuery>::Fetch: FilterFetch,
    <F4 as WorldQuery>::Fetch: FilterFetch,
    <F5 as WorldQuery>::Fetch: FilterFetch,
    <F6 as WorldQuery>::Fetch: FilterFetch,
    <F7 as WorldQuery>::Fetch: FilterFetch,
    <F8 as WorldQuery>::Fetch: FilterFetch,
    <F9 as WorldQuery>::Fetch: FilterFetch,
    <F10 as WorldQuery>::Fetch: FilterFetch,
    <F11 as WorldQuery>::Fetch: FilterFetch,
    <F12 as WorldQuery>::Fetch: FilterFetch,
    <F13 as WorldQuery>::Fetch: FilterFetch,
    <F14 as WorldQuery>::Fetch: FilterFetch, 

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

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

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,
    <F0 as WorldQuery>::Fetch: FilterFetch,
    <F1 as WorldQuery>::Fetch: FilterFetch,
    <F2 as WorldQuery>::Fetch: FilterFetch,
    <F3 as WorldQuery>::Fetch: FilterFetch,
    <F4 as WorldQuery>::Fetch: FilterFetch,
    <F5 as WorldQuery>::Fetch: FilterFetch,
    <F6 as WorldQuery>::Fetch: FilterFetch,
    <F7 as WorldQuery>::Fetch: FilterFetch,
    <F8 as WorldQuery>::Fetch: FilterFetch,
    <F9 as WorldQuery>::Fetch: FilterFetch,
    <F10 as WorldQuery>::Fetch: FilterFetch,
    <F11 as WorldQuery>::Fetch: FilterFetch,
    <F12 as WorldQuery>::Fetch: FilterFetch, 

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

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

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,
    <F0 as WorldQuery>::Fetch: FilterFetch,
    <F1 as WorldQuery>::Fetch: FilterFetch,
    <F2 as WorldQuery>::Fetch: FilterFetch,
    <F3 as WorldQuery>::Fetch: FilterFetch,
    <F4 as WorldQuery>::Fetch: FilterFetch,
    <F5 as WorldQuery>::Fetch: FilterFetch,
    <F6 as WorldQuery>::Fetch: FilterFetch,
    <F7 as WorldQuery>::Fetch: FilterFetch,
    <F8 as WorldQuery>::Fetch: FilterFetch,
    <F9 as WorldQuery>::Fetch: FilterFetch,
    <F10 as WorldQuery>::Fetch: FilterFetch,
    <F11 as WorldQuery>::Fetch: FilterFetch, 

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

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

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,
    <F0 as WorldQuery>::Fetch: FilterFetch,
    <F1 as WorldQuery>::Fetch: FilterFetch,
    <F2 as WorldQuery>::Fetch: FilterFetch,
    <F3 as WorldQuery>::Fetch: FilterFetch,
    <F4 as WorldQuery>::Fetch: FilterFetch,
    <F5 as WorldQuery>::Fetch: FilterFetch,
    <F6 as WorldQuery>::Fetch: FilterFetch,
    <F7 as WorldQuery>::Fetch: FilterFetch, 

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

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

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

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

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

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

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

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

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,
    <F0 as WorldQuery>::Fetch: FilterFetch,
    <F1 as WorldQuery>::Fetch: FilterFetch,
    <F2 as WorldQuery>::Fetch: FilterFetch,
    <F3 as WorldQuery>::Fetch: FilterFetch,
    <F4 as WorldQuery>::Fetch: FilterFetch,
    <F5 as WorldQuery>::Fetch: FilterFetch,
    <F6 as WorldQuery>::Fetch: FilterFetch, 

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

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

impl WorldQuery for Or<()>

type Fetch = Or<()>

type State = Or<()>

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,
    <F0 as WorldQuery>::Fetch: FilterFetch,
    <F1 as WorldQuery>::Fetch: FilterFetch,
    <F2 as WorldQuery>::Fetch: FilterFetch,
    <F3 as WorldQuery>::Fetch: FilterFetch,
    <F4 as WorldQuery>::Fetch: FilterFetch,
    <F5 as WorldQuery>::Fetch: FilterFetch,
    <F6 as WorldQuery>::Fetch: FilterFetch,
    <F7 as WorldQuery>::Fetch: FilterFetch,
    <F8 as WorldQuery>::Fetch: FilterFetch,
    <F9 as WorldQuery>::Fetch: FilterFetch, 

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

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

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,
    <F0 as WorldQuery>::Fetch: FilterFetch,
    <F1 as WorldQuery>::Fetch: FilterFetch,
    <F2 as WorldQuery>::Fetch: FilterFetch,
    <F3 as WorldQuery>::Fetch: FilterFetch,
    <F4 as WorldQuery>::Fetch: FilterFetch,
    <F5 as WorldQuery>::Fetch: FilterFetch,
    <F6 as WorldQuery>::Fetch: FilterFetch,
    <F7 as WorldQuery>::Fetch: FilterFetch,
    <F8 as WorldQuery>::Fetch: FilterFetch, 

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

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

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,
    <F0 as WorldQuery>::Fetch: FilterFetch,
    <F1 as WorldQuery>::Fetch: FilterFetch,
    <F2 as WorldQuery>::Fetch: FilterFetch,
    <F3 as WorldQuery>::Fetch: FilterFetch,
    <F4 as WorldQuery>::Fetch: FilterFetch,
    <F5 as WorldQuery>::Fetch: FilterFetch,
    <F6 as WorldQuery>::Fetch: FilterFetch,
    <F7 as WorldQuery>::Fetch: FilterFetch,
    <F8 as WorldQuery>::Fetch: FilterFetch,
    <F9 as WorldQuery>::Fetch: FilterFetch,
    <F10 as WorldQuery>::Fetch: FilterFetch, 

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

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

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,
    <F0 as WorldQuery>::Fetch: FilterFetch,
    <F1 as WorldQuery>::Fetch: FilterFetch,
    <F2 as WorldQuery>::Fetch: FilterFetch,
    <F3 as WorldQuery>::Fetch: FilterFetch,
    <F4 as WorldQuery>::Fetch: FilterFetch,
    <F5 as WorldQuery>::Fetch: FilterFetch,
    <F6 as WorldQuery>::Fetch: FilterFetch,
    <F7 as WorldQuery>::Fetch: FilterFetch,
    <F8 as WorldQuery>::Fetch: FilterFetch,
    <F9 as WorldQuery>::Fetch: FilterFetch,
    <F10 as WorldQuery>::Fetch: FilterFetch,
    <F11 as WorldQuery>::Fetch: FilterFetch,
    <F12 as WorldQuery>::Fetch: FilterFetch,
    <F13 as WorldQuery>::Fetch: FilterFetch, 

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

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