Struct bevy_internal::ecs::query::Access

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

Tracks read and write access to specific elements in a collection.

Used internally to ensure soundness during system initialization and execution. See the is_compatible and get_conflicts functions.

Implementations

impl<T> Access<T>

where T: SparseSetIndex,

pub const fn new() -> Access<T>

Creates an empty Access collection.

pub fn grow(&mut self, capacity: usize)

Increases the set capacity to the specified amount.

Does nothing if capacity is less than or equal to the current value.

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_archetypal(&mut self, index: T)

Adds an archetypal (indirect) access to the element given by index.

This is for elements whose values are not accessed (and thus will never cause conflicts), but whose presence in an archetype may affect query results.

Currently, this is only used for Has<T>.

pub fn has_read(&self, index: T) -> bool

Returns true if this can access the element given by index.

pub fn has_any_read(&self) -> bool

Returns true if this can access anything.

pub fn has_write(&self, index: T) -> bool

Returns true if this can exclusively access the element given by index.

pub fn has_any_write(&self) -> bool

Returns true if this accesses anything mutably.

pub fn has_archetypal(&self, index: T) -> bool

Returns true if this has an archetypal (indirect) access to the element given by index.

This is an element whose value is not accessed (and thus will never cause conflicts), but whose presence in an archetype may affect query results.

Currently, this is only used for Has<T>.

pub fn read_all(&mut self)

Sets this as having access to all indexed elements (i.e. &World).

pub fn write_all(&mut self)

Sets this as having mutable access to all indexed elements (i.e. EntityMut).

pub fn has_read_all(&self) -> bool

Returns true if this has access to all indexed elements (i.e. &World).

pub fn has_write_all(&self) -> bool

Returns true if this has write access to all indexed elements (i.e. EntityMut).

pub fn clear_writes(&mut self)

Removes all writes.

pub fn clear(&mut self)

Removes all accesses.

pub fn extend(&mut self, other: &Access<T>)

Adds all access from other.

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

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

Access instances are incompatible if one can write an element that the other can read or write.

pub fn is_subset(&self, other: &Access<T>) -> bool

Returns true if the set is a subset of another, i.e. other contains at least all the values in self.

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

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

pub fn reads_and_writes(&self) -> impl Iterator<Item = T>

Returns the indices of the elements this has access to.

pub fn reads(&self) -> impl Iterator<Item = T>

Returns the indices of the elements this has non-exclusive access to.

pub fn writes(&self) -> impl Iterator<Item = T>

Returns the indices of the elements this has exclusive access to.

pub fn archetypal(&self) -> impl Iterator<Item = T>

Returns the indices of the elements that this has an archetypal access to.

These are elements whose values are not accessed (and thus will never cause conflicts), but whose presence in an archetype may affect query results.

Currently, this is only used for Has<T>.

Trait Implementations

impl<T> Clone for Access<T>

where T: Clone + SparseSetIndex,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Access<T>

where T: SparseSetIndex + Debug,

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

Formats the value using the given formatter.

impl<T> Default for Access<T>

where T: SparseSetIndex,

fn default() -> Access<T>

Returns the “default value” for a type.

impl<T> PartialEq for Access<T>

where T: PartialEq + SparseSetIndex,

fn eq(&self, other: &Access<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 Access<T>

where T: Eq + SparseSetIndex,

impl<T> StructuralEq for Access<T>

where T: SparseSetIndex,

impl<T> StructuralPartialEq for Access<T>

where T: SparseSetIndex,