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() -> Access

Creates an empty Access collection.

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

Adds access to the component given by index.

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

Adds exclusive access to the component given by index.

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

Adds access to the resource given by index.

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

Adds exclusive access to the resource given by index.

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

Removes both read and write access to the component given by index.

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_component_read followed by a call to extend with a call to extend followed by a call to remove_component_read.

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

Removes write access to the component given by index.

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_component_write followed by a call to extend with a call to extend followed by a call to remove_component_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_component_read(&self, index: ComponentId) -> bool

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

pub fn has_any_component_read(&self) -> bool

Returns true if this can access any component.

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

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

pub fn has_any_component_write(&self) -> bool

Returns true if this accesses any component mutably.

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

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

pub fn has_any_resource_read(&self) -> bool

Returns true if this can access any resource.

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

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

pub fn has_any_resource_write(&self) -> bool

Returns true if this accesses any resource mutably.

pub fn has_any_read(&self) -> bool

Returns true if this accesses any resources or components.

pub fn has_any_write(&self) -> bool

Returns true if this accesses any resources or components 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_components(&mut self)

Sets this as having access to all components (i.e. EntityRef).

pub fn write_all_components(&mut self)

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

pub const fn read_all_resources(&mut self)

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

pub const fn write_all_resources(&mut self)

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

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. &mut World).

pub fn has_read_all_components(&self) -> bool

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

pub fn has_write_all_components(&self) -> bool

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

pub fn has_read_all_resources(&self) -> bool

Returns true if this has access to all resources (i.e. EntityRef).

pub fn has_write_all_resources(&self) -> bool

Returns true if this has write access to all resources (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. &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_components_compatible(&self, other: &Access) -> bool

Returns true if the access and other can be active at the same time, only looking at their component access.

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

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

Returns true if the access and other can be active at the same time, only looking at their resource access.

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

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_components(&self, other: &Access) -> bool

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

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

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

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 resource_reads_and_writes(&self) -> impl Iterator<Item = ComponentId>

Returns the indices of the resources this has access to.

pub fn resource_reads(&self) -> impl Iterator<Item = ComponentId>

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

pub fn resource_writes(&self) -> impl Iterator<Item = ComponentId>

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

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

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_iter_component_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_component_read(ComponentId::new(1));
access.add_component_write(ComponentId::new(2));
access.add_archetypal(ComponentId::new(3));

let result = access
    .try_iter_component_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) -> Access

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Access

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

Formats the value using the given formatter.

impl Default for Access

fn default() -> Access

Returns the “default value” for a type.

impl PartialEq for Access

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for Access

impl StructuralPartialEq for Access