Trait bevy::ecs::query::FetchState[−]

pub unsafe trait FetchState: Send + Sync {
    pub fn init(world: &mut World) -> Self;
    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;
}

State used to construct a Fetch. This will be cached inside QueryState, so it is best to move as much data / computation here as possible to reduce the cost of constructing Fetch. SAFETY: Implementor must ensure that FetchState::update_component_access and FetchState::update_archetype_component_access exactly reflects the results of FetchState::matches_archetype, FetchState::matches_table, Fetch::archetype_fetch, and Fetch::table_fetch

Required methods

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

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

Loading content...

Implementations on Foreign Types

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

`pub fn init(_world: &mut World)`

`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 (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 ) -> (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<F0, F1, F2, F3, F4, F5, F6, F7, F8> FetchState for (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) -> (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> FetchState for (F0, F1) where F0: FetchState, F1: FetchState,`

`pub fn init(_world: &mut World) -> (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, F6, F7, F8, F9, F10, F11, F12, F13> FetchState for (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 ) -> (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, F3, F4, F5, F6, F7, F8, F9, F10, F11> FetchState for (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 ) -> (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 (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 ) -> (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, F1, F2, F3, F4, F5, F6> FetchState for (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) -> (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> FetchState for (F0, F1, F2) where F0: FetchState, F1: FetchState, F2: FetchState,`

`pub fn init(_world: &mut World) -> (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> FetchState for (F0,) where F0: FetchState,`

`pub fn init(_world: &mut World) -> (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, F2, F3, F4, F5, F6, F7, F8, F9> FetchState for (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) -> (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> FetchState for (F0, F1, F2, F3, F4) where F0: FetchState, F1: FetchState, F2: FetchState, F3: FetchState, F4: FetchState,`

`pub fn init(_world: &mut World) -> (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> FetchState for (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) -> (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, F7, F8, F9, F10> FetchState for (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) -> (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> FetchState for (F0, F1, F2, F3) where F0: FetchState, F1: FetchState, F2: FetchState, F3: FetchState,`

`pub fn init(_world: &mut World) -> (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`

Loading content...

Implementors

`impl FetchState for EntityState`

`pub fn init(_world: &mut World) -> EntityState`

`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> 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> 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> 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> 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> 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> 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> 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, 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, 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, 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, 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<T> FetchState for AddedState<T> where T: Component,`

`pub fn init(world: &mut World) -> AddedState<T>`

`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<T> FetchState for ChangeTrackersState<T> where T: Component,`

`pub fn init(world: &mut World) -> ChangeTrackersState<T>`

`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<T> FetchState for ChangedState<T> where T: Component,`

`pub fn init(world: &mut World) -> ChangedState<T>`

`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<T> FetchState for OptionState<T> where T: FetchState,`

`pub fn init(world: &mut World) -> OptionState<T>`

`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<T> FetchState for ReadState<T> where T: Component,`

`pub fn init(world: &mut World) -> ReadState<T>`

`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<T> FetchState for WithBundleState<T> where T: Bundle,`

`pub fn init(world: &mut World) -> WithBundleState<T>`

`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<T> FetchState for WithState<T> where T: Component,`

`pub fn init(world: &mut World) -> WithState<T>`

`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<T> FetchState for WithoutState<T> where T: Component,`

`pub fn init(world: &mut World) -> WithoutState<T>`

`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<T> FetchState for WriteState<T> where T: Component,`

`pub fn init(world: &mut World) -> WriteState<T>`

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

Loading content...

Trait bevy::ecs::query::FetchState[−]

Required methods

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

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

Implementations on Foreign Types

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

pub fn init(_world: &mut World)

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

pub fn init( _world: &mut World) -> (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<F0, F1, F2, F3, F4, F5, F6, F7, F8> FetchState for (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) -> (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> FetchState for (F0, F1) where F0: FetchState, F1: FetchState,

pub fn init(_world: &mut World) -> (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

pub fn init( _world: &mut World) -> (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

pub fn init( _world: &mut World) -> (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

pub fn init( _world: &mut World) -> (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, F1, F2, F3, F4, F5, F6> FetchState for (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) -> (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> FetchState for (F0, F1, F2) where F0: FetchState, F1: FetchState, F2: FetchState,

pub fn init(_world: &mut World) -> (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> FetchState for (F0,) where F0: FetchState,

pub fn init(_world: &mut World) -> (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, F2, F3, F4, F5, F6, F7, F8, F9> FetchState for (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) -> (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> FetchState for (F0, F1, F2, F3, F4) where F0: FetchState, F1: FetchState, F2: FetchState, F3: FetchState, F4: FetchState,

pub fn init(_world: &mut World) -> (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 init(world: &mut World) -> Self`

`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 (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) -> (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 FetchState for ()`

`pub fn init(_world: &mut World)`

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

`pub fn init( _world: &mut World ) -> (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<F0, F1, F2, F3, F4, F5, F6, F7, F8> FetchState for (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) -> (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> FetchState for (F0, F1) where F0: FetchState, F1: FetchState,`

`pub fn init(_world: &mut World) -> (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`

`pub fn init( _world: &mut World ) -> (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`

`pub fn init( _world: &mut World ) -> (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`

`pub fn init( _world: &mut World ) -> (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, F1, F2, F3, F4, F5, F6> FetchState for (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) -> (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> FetchState for (F0, F1, F2) where F0: FetchState, F1: FetchState, F2: FetchState,`

`pub fn init(_world: &mut World) -> (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> FetchState for (F0,) where F0: FetchState,`

`pub fn init(_world: &mut World) -> (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, F2, F3, F4, F5, F6, F7, F8, F9> FetchState for (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) -> (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> FetchState for (F0, F1, F2, F3, F4) where F0: FetchState, F1: FetchState, F2: FetchState, F3: FetchState, F4: FetchState,`

`pub fn init(_world: &mut World) -> (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> FetchState for (F0, F1, F2, F3, F4, F5) where F0: FetchState, F1: FetchState, F2: FetchState, F3: FetchState, F4: FetchState, F5: FetchState,`