Struct hecs_schedule::SubWorldRaw

pub struct SubWorldRaw<A, T> { /* private fields */ }

Represents a borrow of the world which can only access a subset of components (unless AllAccess is used).

This type allows for any reference kind, such as &World, AtomicRef, Ref, etc.

Type alises are provided for the most common usages, with SubWorld being the one used by Schedule.

Implementations

impl<A, T> SubWorldRaw<A, T>

pub fn new(world: A) -> Self

Splits the world into a subworld. No borrow checking is performed so may fail during query unless guarded otherwise.

impl<A, T: ComponentBorrow> SubWorldRaw<A, T>

pub fn has<U: IntoAccess>(&self) -> bool

Returns true if the subworld can access the borrow of T

pub fn has_all<U: Subset>(&self) -> bool

Returns true if the world satisfies the whole query

impl<'w, A: 'w + Deref<Target = World>, T: ComponentBorrow> SubWorldRaw<A, T>

pub fn query<Q: Query + Subset>(&self) -> QueryBorrow<'_, Q>

Query the subworld.

Panics

Panics if the query items are not a compatible subset of the subworld.

pub fn query_one<Q: Query + Subset>(
    &'w self,
    entity: Entity
) -> Result<QueryOne<'w, Q>>

Query the subworld for a single entity. Wraps the hecs::NoSuchEntity error and provides the entity id

pub fn get<C: Component>(&self, entity: Entity) -> Result<Ref<'_, C>>

Get a single component from the world.

Wraps the hecs::NoSuchEntity error and provides the entity id

pub fn get_mut<C: Component>(&self, entity: Entity) -> Result<RefMut<'_, C>>

Get a single component from the world.

Wraps the hecs::NoSuchEntity error and provides the entity id

pub fn reserve_entities(&self, count: u32) -> impl Iterator<Item = Entity> + '_

Reserve multiple entities concurrently

pub fn query_par<Q: Query + Subset>(&self) -> QueryBorrow<'_, Q>

Query the subworld.

Panics

Panics if the query items are not a compatible subset of the subworld.

impl<A: Deref<Target = World>, T: Query> SubWorldRaw<A, T>

pub fn native_query(&self) -> QueryBorrow<'_, T>

Query the full access of the subworld. Does not fail as access is guaranteed

impl<A: ExternalClone, T: ComponentBorrow> SubWorldRaw<A, T>

pub fn split<U: ComponentBorrow + Subset>(&self) -> Result<SubWorldRaw<A, U>>

Splits the subworld further into a compatible subworld. Fails if not compatible

Trait Implementations

impl<A, T: ComponentBorrow + Query> ComponentBorrow for SubWorldRaw<A, T>

fn borrows() -> Borrows

Returns a list of all component accesses

fn has<U: IntoAccess>() -> bool

Returns true if U exists in Self

fn has_dynamic(id: TypeId, exclusive: bool) -> bool

Returns true if id exists in Self

impl<A: ExternalClone, T: ComponentBorrow, U: ComponentBorrow + Subset> From<&'_ SubWorldRaw<A, T>> for SubWorldRaw<A, U>

fn from(value: &SubWorldRaw<A, T>) -> Self

Performs the conversion.

impl<'a, T> From<&'a Context<'a>> for SubWorldRaw<AtomicRef<'a, World>, T>

fn from(context: &'a Context<'_>) -> Self

Performs the conversion.

impl<'a, 'b, T: ComponentBorrow, U: ComponentBorrow + Subset> From<&'b SubWorldRaw<AtomicRef<'a, World>, T>> for SubWorldRef<'b, U>

fn from(subworld: &'b SubWorld<'a, T>) -> Self

Performs the conversion.

impl<A, T> From<A> for SubWorldRaw<A, T>

fn from(world: A) -> Self

Performs the conversion.

impl<A: Deref<Target = World>, T: ComponentBorrow> GenericWorld for SubWorldRaw<A, T>

fn reserve(&self) -> Entity

Reserve an entity

fn to_ref<U: ComponentBorrow + Subset>(&self) -> SubWorldRef<'_, U>

Convert the subworld into another holding an internal reference to the original world.

fn try_query<Q: Query + Subset>(&self) -> Result<QueryBorrow<'_, Q>>

Queries the world

fn try_query_one<Q: Query + Subset>(
    &self,
    entity: Entity
) -> Result<QueryOne<'_, Q>>

Queries the world for a specific entity

fn try_get<C: Component>(&self, entity: Entity) -> Result<Ref<'_, C>>

Get a single component for an entity Returns the contextual result since hecs-schedule is required to be imported anyway

fn try_get_mut<C: Component>(&self, entity: Entity) -> Result<RefMut<'_, C>>

Get a single component for an entity Returns the contextual result since hecs-schedule is required to be imported anyway

fn to_empty(&self) -> EmptyWorld<'_>

Transform this into a subworld which borrows no components. This is useful for concurrent access of entities.

impl<'a, A, T> View<'a> for SubWorldRaw<A, T> where
    A: Deref<Target = World>,
    T: ComponentBorrow, 

type Superset = A

The type which View comes from

fn split(world: Self::Superset) -> Self

Splits from the containing superset