Struct bevy::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 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 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(&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 get_conflicts(&self, other: &Access<T>) -> Vec<T, Global>

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.

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<Access<T>> for Access<T>where T: PartialEq<T> + 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,