Struct Access 

pub struct Access { /* 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 Access

pub const fn new() -> Self

Creates an empty Access collection.

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

Adds access to the component given by index.

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

Adds exclusive access to the component given by index.

pub fn remove_read(&mut self, index: ComponentId)

Removes read access to the component given by index.

This also removes write access, since if you can’t even read a component, you also can’t write to it.

Because this method corresponds to the set difference operator ∖, it can create complicated logical formulas that you should verify correctness of. For example, A ∪ (B ∖ A) isn’t equivalent to (A ∪ B) ∖ A, so you can’t replace a call to Self::remove_read followed by a call to Self::extend with a call to Self::extend followed by a call to Self::remove_read.

pub fn remove_write(&mut self, index: ComponentId)

Removes write access to the component given by index.

Unlike Self::remove_read, this method only removes write access, since it’s reasonable to “downgrade” write access to only read access.

Because this method corresponds to the set difference operator ∖, it can create complicated logical formulas that you should verify correctness of. For example, A ∪ (B ∖ A) isn’t equivalent to (A ∪ B) ∖ A, so you can’t replace a call to remove_write followed by a call to extend with a call to extend followed by a call to remove_write.

pub fn add_archetypal(&mut self, index: ComponentId)

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

This is for components 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> and Allow<T>.

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

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

pub fn has_any_read(&self) -> bool

Returns true if this can access any component.

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

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

pub fn has_any_write(&self) -> bool

Returns true if this accesses any component mutably.

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

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

This is a component 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 components (i.e. EntityRef and &World).

pub fn write_all(&mut self)

Sets this as having mutable access to all components (i.e. EntityMut and &mut World).

pub fn has_read_all(&self) -> bool

Returns true if this has access to all components (i.e. EntityRef and &World).

pub fn has_write_all(&self) -> bool

Returns true if this has write access to all components (i.e. EntityMut and &mut World).

pub fn clear_writes(&mut self)

Removes all writes.

pub fn clear(&mut self)

Removes all accesses.

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

Adds all access from other.

pub fn remove_conflicting_access(&mut self, other: &Access)

Removes any access from self that would conflict with other. This removes any reads and writes for any component written by other, and removes any writes for any component read by other.

pub fn is_compatible(&self, other: &Access) -> 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) -> 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) -> AccessConflicts

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

pub fn archetypal(&self) -> &ComponentIdSet

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

These are components 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 try_reads_and_writes( &self, ) -> Result<&ComponentIdSet, UnboundedAccessError>

👎Deprecated since 0.20.0:

use `reads_and_writes().as_finite_set()

Returns the set of components with read access, or an error if the access is unbounded.

This includes components with write access, since write access also allows you to read the component.

pub fn reads(&self) -> &InvertibleComponentIdSet

Returns the set of components with read or write access.

This includes components with write access, since write access also allows you to read the component.

pub fn try_writes(&self) -> Result<&ComponentIdSet, UnboundedAccessError>

👎Deprecated since 0.20.0:

use `writes().as_finite_set()

Returns the set of components with write access, or an error if the access is unbounded.

pub fn writes(&self) -> &InvertibleComponentIdSet

Returns the set of components with write access.

pub fn try_iter_access( &self, ) -> Result<impl Iterator<Item = ComponentAccessKind> + '_, UnboundedAccessError>

Returns an iterator over the component IDs and their ComponentAccessKind.

Returns Err(UnboundedAccess) if the access is unbounded. This typically occurs when an Access is marked as accessing all components, and then adding exceptions.

Examples

let mut access = Access::default();

access.add_read(ComponentId::new(1));
access.add_write(ComponentId::new(2));
access.add_archetypal(ComponentId::new(3));

let result = access
    .try_iter_access()
    .map(Iterator::collect::<Vec<_>>);

assert_eq!(
    result,
    Ok(vec![
        ComponentAccessKind::Shared(ComponentId::new(1)),
        ComponentAccessKind::Exclusive(ComponentId::new(2)),
        ComponentAccessKind::Archetypal(ComponentId::new(3)),
    ]),
);

Trait Implementations

impl Clone for Access

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Access

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

Formats the value using the given formatter.

impl Default for Access

fn default() -> Access

Returns the “default value” for a type.

impl Eq for Access

impl PartialEq for Access

fn eq(&self, other: &Access) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Access