Struct Union

pub struct Union<T>(pub T);

Unionized the slot-level filter of two fetches, but requires the individual fetches to still match.

This allows the filters to return fetch items side by side like the wrapped fetch would, since all constituent fetches are satisfied, but not necessarily all their entities.

This is most useful for change queries, where you care about about any change, but still require the entity to have all the components, and have them returned despite not all having changed.

For this to implement Fetch, T::Prepared must implement UnionFilter.

Tuple Fields

0: T

Trait Implementations

impl<T: Clone> Clone for Union<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Union<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'w, T> Fetch<'w> for Union<T>

where T: Fetch<'w>, T::Prepared: UnionFilter,

const MUTABLE: bool = T::MUTABLE

true if the fetch mutates any component and thus needs a change event

type Prepared = Union<<T as Fetch<'w>>::Prepared>

The prepared version of the fetch

fn prepare(&'w self, data: FetchPrepareData<'w>) -> Option<Self::Prepared>

Prepares the fetch for an archetype by acquiring borrows.

fn filter_arch(&self, data: FetchAccessData<'_>) -> bool

Returns true if the archetype matches the fetch

fn access(&self, data: FetchAccessData<'_>, dst: &mut Vec<Access>)

Returns which components and how will be accessed for an archetype.

fn describe(&self, f: &mut Formatter<'_>) -> Result

Describes the fetch in a human-readable fashion

fn searcher(&self, _searcher: &mut ArchetypeSearcher)

Returns the required component for the fetch.

fn by_ref(&self) -> RefFetch<'_, Self>

where Self: Sized,

Convert the fetch to a reference type which works with HRTB

impl<'q, T> FetchItem<'q> for Union<T>

where T: FetchItem<'q>,

type Item = <T as FetchItem<'q>>::Item

The item yielded by the prepared fetch

impl<'q, T> PreparedFetch<'q> for Union<T>

where T: PreparedFetch<'q> + UnionFilter,

const HAS_FILTER: bool = T::HAS_UNION_FILTER

Indicates if the fetch will provide any filtering of slots.

type Item = <T as PreparedFetch<'q>>::Item

Item returned by fetch

type Chunk = <T as PreparedFetch<'q>>::Chunk

A chunk accessing a disjoint set of the borrow sequentially

unsafe fn filter_slots(&mut self, slots: Slice) -> Slice

Filter the slots to visit Returns the leftmost subslice of slots which should be visited

unsafe fn create_chunk(&'q mut self, slots: Slice) -> Self::Chunk

Creates a chunk to access a slice of the borrow

unsafe fn fetch_next(chunk: &mut Self::Chunk) -> Self::Item

Fetch the item from entity at the slot in the prepared storage.

impl<T> UnionFilter for Union<T>

where T: UnionFilter,

const HAS_UNION_FILTER: bool = T::HAS_UNION_FILTER

The union may not have the same filter behavior as a normal filter as sub-filters are combined using or instead of and. This means any non-filter will cause the whole tuple to always yield.

unsafe fn filter_union(&mut self, slots: Slice) -> Slice

Safety