Struct despero::ecs::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) -> SubWorldRaw<A, T>

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

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

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

Returns true if the subworld can access the borrow of T

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

Returns true if the world satisfies the whole query

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

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

Query the subworld.

Panics

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

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

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

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

Get a single component from the world.

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

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

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>(&self) -> QueryBorrow<'_, Q>where Q: Query + Subset,

Query the subworld.

Panics

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

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

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

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

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

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

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

Trait Implementations

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

fn borrows() -> SmallVec<[Access; 8]>

Returns a list of all component accesses

fn has<U>() -> boolwhere U: IntoAccess,

Returns true if U exists in Self

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

Returns true if id exists in Self

impl<'a, T> ContextBorrow<'a> for SubWorldRaw<AtomicRef<'a, World>, T>

type Target = SubWorldRaw<AtomicRef<'a, World>, T>

The resulting type after borrowing from context

fn borrow( context: &'a Context<'_> ) -> Result<SubWorldRaw<AtomicRef<'a, World>, T>, Error>

Borrow type from context

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

fn from(context: &'a Context<'_>) -> SubWorldRaw<AtomicRef<'a, World>, T>

Converts to this type from the input type.

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

fn from( subworld: &'b SubWorldRaw<AtomicRef<'a, World>, T> ) -> SubWorldRaw<&'b World, U>

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

fn from(world: A) -> SubWorldRaw<A, T>

Converts to this type from the input type.

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

fn reserve(&self) -> Entity

Reserve an entity

fn to_ref<U>(&self) -> SubWorldRaw<&World, U>where U: ComponentBorrow + Subset,

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

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

Queries the world

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

Queries the world for a specific entity

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

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>(&self, entity: Entity) -> Result<RefMut<'_, C>, Error>where C: Component,

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

fn to_empty(&self) -> SubWorldRaw<&World, ()>

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

impl<T> IntoBorrow for SubWorldRaw<AtomicRef<'_, World>, T>where T: Component,

type Borrow = SubWorldBorrower<T>

The borrow type

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: <SubWorldRaw<A, T> as View<'a>>::Superset) -> SubWorldRaw<A, T>

Splits from the containing superset