Struct legion::world::SubWorld

pub struct SubWorld<'a> { /* fields omitted */ }

Provides access to a subset of the entities of a World.

To access a component mutably in a world, such as inside a query or via an EntryMut, you need to borrow the entire world mutably. This prevents you from accessing any other data in the world at the same time.

In some cases, we can work around this by splitting the world. We can split a world around the component types requested by a View. This will create two subworlds, the left one allowing access only to the components (and mutability) declared by the view, while the right subworld will allow access to everything but those components.

Subworlds can be recustively further split.

Implementations

impl<'a> SubWorld<'a>

pub unsafe fn new_unchecked(
    world: &'a World,
    components: ComponentAccess<'a>,
    archetypes: Option<&'a BitSet>
) -> Self

Constructs a new SubWorld.

Safety

Queries assume that this type has been constructed correctly. Ensure that sub-worlds represent disjoint portions of a world and that the world is not used while any of its sub-worlds are alive.

pub fn split<'b, T: IntoView>(&'b mut self) -> (SubWorld<'b>, SubWorld<'b>) where
    'a: 'b, 

Splits the world into two. The left world allows access only to the data declared by the view; the right world allows access to all else.

Examples

let (left, right) = world.split::<&mut Position>();

With the above, ‘left’ contains a sub-world with access only to &Position and &mut Position, and right contains a sub-world with access to everything but &Position and &mut Position.

let (left, right) = world.split::<&Position>();

In this second example, left is provided access only to &Position. right is granted permission to everything but &mut Position.

pub fn split_for_query<'q, V: IntoView, F: EntityFilter>(
    &mut self,
    _: &'q Query<V, F>
) -> (SubWorld<'_>, SubWorld<'_>)

Splits the world into two. The left world allows access only to the data declared by the query’s view; the right world allows access to all else.

Trait Implementations

impl<'a> Clone for SubWorld<'a>

fn clone(&self) -> SubWorld<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> EntityStore for SubWorld<'a>

fn get_component_storage<V: for<'b> View<'b>>(
    &self
) -> Result<StorageAccessor<'_>, EntityAccessError>

Returns a component storage accessor for component types declared in the specified View.

fn entry_ref(&self, entity: Entity) -> Result<EntryRef<'_>, EntityAccessError>

Returns an entity entry which can be used to access entity metadata and components.

fn entry_mut(
    &mut self,
    entity: Entity
) -> Result<EntryMut<'_>, EntityAccessError>

Returns a mutable entity entry which can be used to access entity metadata and components.

fn id(&self) -> WorldId

Returns the world’s unique ID.

impl<'a> From<&'a mut World> for SubWorld<'a>

fn from(world: &'a mut World) -> Self

Performs the conversion.