Struct aery::operations::utils::Relations

pub struct Relations<RS: RelationSet> { /* private fields */ }

[WorldQuery] type to query for Relation types. Takes a RelationSet which is a single relation or tuple of relation types. Must appear in the second position of the outer most tuple to use relation operations and no type may appear more than once for operations to work.

Trait Implementations

impl<RS: RelationSet> QueryData for Relations<RS>

SAFETY: we assert fields are readonly below

type ReadOnly = Relations<RS>

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

impl<RS: RelationSet> WorldQuery for Relations<RS>

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

SAFETY: we call set_archetype for each member that implements Fetch

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

SAFETY: we call set_table for each member that implements Fetch

unsafe fn fetch<'__w>( _fetch: &mut <Self as WorldQuery>::Fetch<'__w>, _entity: Entity, _table_row: TableRow ) -> <Self as WorldQuery>::Item<'__w>

SAFETY: we call fetch for each member that implements Fetch.

type Item<'__w> = RelationsItem<'__w, RS>

The item returned by this WorldQuery For QueryData this will be the item returned by the query. For QueryFilter this will be either (), or a bool indicating whether the entity should be included or a tuple of such things.

type Fetch<'__w> = RelationsFetch<'__w, RS>

Per archetype/table state used by this WorldQuery to fetch Self::Item

type State = RelationsState<RS>

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

fn shrink<'__wlong: '__wshort, '__wshort>( item: <Relations<RS> as WorldQuery>::Item<'__wlong> ) -> <Relations<RS> as WorldQuery>::Item<'__wshort>

This function manually implements subtyping for the query items.

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

Creates a new instance of this fetch.

const IS_DENSE: bool = _

Returns true if (and only if) every table of every archetype matched by this fetch contains all of the matched components. This is used to select a more efficient “table iterator” for “dense” queries. If this returns true, WorldQuery::set_table must be used before WorldQuery::fetch can be called for iterators. If this returns false, WorldQuery::set_archetype must be used before WorldQuery::fetch can be called for iterators.

fn update_component_access( state: &Self::State, _access: &mut FilteredAccess<ComponentId> )

Adds any component accesses used by this WorldQuery to access.

fn init_state(world: &mut World) -> RelationsState<RS>

Creates and initializes a State for this WorldQuery type.

fn get_state(world: &World) -> Option<RelationsState<RS>>

Attempts to initializes a State for this WorldQuery type.

fn matches_component_set( state: &Self::State, _set_contains_id: &impl Fn(ComponentId) -> bool ) -> bool

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

fn set_access(_state: &mut Self::State, _access: &FilteredAccess<ComponentId>)

Sets available accesses for implementors with dynamic access such as FilteredEntityRef or FilteredEntityMut.

impl<RS: RelationSet> ReadOnlyQueryData for Relations<RS>

SAFETY: we assert fields are readonly below