Struct bevy::ecs::query::FilteredAccess

pub struct FilteredAccess<T> where
    T: SparseSetIndex, { /* private fields */ }

An Access that has been filtered to include and exclude certain combinations of elements.

Used internally to statically check if queries are disjoint.

Subtle: a read or write in access should not be considered to imply a with access.

For example consider Query<Option<&T>> this only has a read of T as doing otherwise would allow for queries to be considered disjoint that actually aren’t:

• Query<(&mut T, Option<&U>)> read/write T, read U, with U
• Query<&mut T, Without<U>> read/write T, without U from this we could reasonably conclude that the queries are disjoint but they aren’t.

In order to solve this the actual access that Query<(&mut T, Option<&U>)> has is read/write T, read U. It must still have a read U access otherwise the following queries would be incorrectly considered disjoint:

• Query<&mut T> read/write T
• Query<Option<&T> accesses nothing

See comments the WorldQuery impls of AnyOf/Option/Or for more information.

Implementations

impl<T> FilteredAccess<T> where
    T: SparseSetIndex, 

pub fn access(&self) -> &Access<T>

Returns a reference to the underlying unfiltered access.

pub fn access_mut(&mut self) -> &mut Access<T>

Returns a mutable reference to the underlying unfiltered access.

pub fn add_read(&mut self, index: T)

Adds access to the element given by index.

pub fn add_write(&mut self, index: T)

Adds exclusive access to the element given by index.

pub fn add_with(&mut self, index: T)

Retains only combinations where the element given by index is also present.

pub fn add_without(&mut self, index: T)

Retains only combinations where the element given by index is not present.

pub fn extend_intersect_filter(&mut self, other: &FilteredAccess<T>)

pub fn extend_access(&mut self, other: &FilteredAccess<T>)

pub fn is_compatible(&self, other: &FilteredAccess<T>) -> bool

Returns true if this and other can be active at the same time.

pub fn get_conflicts(&self, other: &FilteredAccess<T>) -> Vec<T, Global>

Returns a vector of elements that this and other cannot access at the same time.

pub fn extend(&mut self, access: &FilteredAccess<T>)

Adds all access and filters from other.

pub fn read_all(&mut self)

Sets the underlying unfiltered access as having access to all indexed elements.

Trait Implementations

impl<T> Clone for FilteredAccess<T> where
    T: Clone + SparseSetIndex, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for FilteredAccess<T> where
    T: Debug + SparseSetIndex, 

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

Formats the value using the given formatter.

impl<T> Default for FilteredAccess<T> where
    T: SparseSetIndex, 

fn default() -> FilteredAccess<T>

Returns the “default value” for a type.

impl<T> From<FilteredAccess<T>> for FilteredAccessSet<T> where
    T: SparseSetIndex, 

fn from(filtered_access: FilteredAccess<T>) -> FilteredAccessSet<T>

Converts to this type from the input type.

impl<T> PartialEq<FilteredAccess<T>> for FilteredAccess<T> where
    T: PartialEq<T> + SparseSetIndex, 

fn eq(&self, other: &FilteredAccess<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Eq for FilteredAccess<T> where
    T: Eq + SparseSetIndex, 

impl<T> StructuralEq for FilteredAccess<T> where
    T: SparseSetIndex, 

impl<T> StructuralPartialEq for FilteredAccess<T> where
    T: SparseSetIndex,