Enum SystemAccess 

pub enum SystemAccess {
    None,
    Shared(FilteredAccessSet),
    Exclusive,
}

Represents the access a System requires to the World.

Variants

None

The system does not access the world at all.

Shared(FilteredAccessSet)

The system requires shared access to the world, which means it can run in parallel with other systems that also require shared access, as long as they don’t require exclusive access to the same components.

Exclusive

The system requires exclusive access to the world, meaning no other Shared or Exclusive system can run in parallel with it.

Implementations

impl SystemAccess

pub fn is_none(&self) -> bool

Returns true if the system does not access the world at all, so it can run in parallel with any other system.

pub fn is_shared(&self) -> bool

Returns true if the system requires shared access to the world, which means it can run in parallel with other systems that also require shared access, as long as they don’t require exclusive access to the same components.

pub fn is_exclusive(&self) -> bool

Returns true if the system requires exclusive access to the world.

pub fn is_compatible(&self, other: &Self) -> bool

Returns true if this system’s access is compatible with the other system’s access, such that they can run in parallel without conflicting with each other.

pub fn get_conflicts_single( &self, filtered_access: &FilteredAccess, ) -> AccessConflicts

Returns the conflicts between the system’s current access and the provided access.

• If the system currently has None access, it will return an empty AccessConflicts (i.e. no conflicts).
• If the system currently has Shared access, the conflicts between individual components or resources will be returned.
• If the system currently has Exclusive access, it will return AccessConflicts::All.

pub fn get_conflicts(&self, other: &Self) -> AccessConflicts

Returns the conflicts between the system’s current access and another system’s access.

• If either system has None access, it will return an empty AccessConflicts (i.e. no conflicts).
• If both systems have Shared access, the conflicts between individual components or resources will be returned.
• If either system has Exclusive access, it will return AccessConflicts::All.

pub fn to_filtered_access_set(&self) -> Cow<'_, FilteredAccessSet>

Converts the system’s current access into a FilteredAccessSet.

pub fn require_shared_access<T>( &mut self, system_meta: &SystemMeta, ) -> &mut FilteredAccessSet

Marks the system as requiring shared access to the world, which means it can run in parallel with other systems that also require shared access, as long as they don’t require exclusive access to the same components.

The provided type T is used for error reporting in case of access conflicts; it should be the type of the system parameter that is requesting shared access.

Panics

If the system already has exclusive access, this method will panic with an error message indicating the conflict.

Examples

Only metadata access required

If a system parameter requires access to world metadata but not any particular components, you may call this function without modifying the returned FilteredAccessSet:

pub struct MyWorldId(WorldId);

// SAFETY: World metadata is registered and accessed.
unsafe impl SystemParam for MyWorldId {
    type State = ();
    type Item<'world, 'state> = MyWorldId;

    fn init_state(_: &mut World) -> Self::State {}

    fn init_access(
        _state: &Self::State,
        system_meta: &mut SystemMeta,
        system_access: &mut SystemAccess,
        _world: &mut World,
    ) {
        system_access.require_shared_access::<Self>(system_meta);
    }

    unsafe fn get_param<'world, 'state>(
        _: &'state mut Self::State,
        _: &SystemMeta,
        world: UnsafeWorldCell<'world>,
        _: Tick,
    ) -> Result<Self::Item<'world, 'state>, SystemParamValidationError> {
        Ok(MyWorldId(world.id()))
    }
}

pub fn require_exclusive_access<T>(&mut self, system_meta: &SystemMeta)

Marks the system as requiring exclusive access to the world, meaning no other Shared or Exclusive system can run in parallel with it.

The provided type T is used for error reporting in case of access conflicts; it should be the type of the system parameter that is requesting exclusive access.

Panics

If the system already has shared or exclusive access, this method will panic with an error message indicating the conflict.

pub fn try_add( &mut self, filtered_access: FilteredAccess, ) -> Result<(), AccessConflicts>

Attempts to add the provided FilteredAccess to the system’s current access.

• If the system currently has None access, it will change this access to Shared and add the provided FilteredAccess.
• If the system currently has Shared access, it will check for conflicts with the provided FilteredAccess. If there are no conflicts, it will add the provided FilteredAccess. If there are conflicts, it will return an AccessConflicts error.
• If the system currently has Exclusive access, it will error with AccessConflicts::All.

Errors

If there are conflicts with the system’s current access, an AccessConflicts error will be returned.

pub fn ensure_filtered_access(&mut self, filtered_access: FilteredAccess)

Marks the system as requiring access to certain or all components or resources in the World.

pub fn ensure_metadata_access(&mut self)

Marks the system as requiring access to World metadata (e.g. Archetypes, Components, etc.).

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

Merges the provided SystemAccess into the system’s current access.

Trait Implementations

impl Clone for SystemAccess

fn clone(&self) -> SystemAccess

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SystemAccess

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

Formats the value using the given formatter.

impl Default for SystemAccess

fn default() -> SystemAccess

Returns the “default value” for a type.

impl Eq for SystemAccess

impl PartialEq for SystemAccess

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for SystemAccess