Struct goggles::entity::Allocator

pub struct Allocator { /* fields omitted */ }

Implementations

impl Allocator

pub fn new() -> Allocator

pub fn kill(&mut self, entity: Entity) -> Result<(), WrongGeneration>

Kill the given entity.

Will return Err(WrongGeneration) if the given entity is not the current generation in this allcoator.

pub fn kill_atomic(&self, e: Entity) -> Result<(), WrongGeneration>

Mark an entity to be killed on the next call to Allocator::merge_atomic.

The entity's state is not changed at all until the next call to Allocator::merge_atomic, it is still considered live and may even have Allocator::kill_atomic called on it multiple times.

If the entity is not current at the time of this call, however, then this will return Err(WrongGeneration).

pub fn is_alive(&self, e: Entity) -> bool

Returns whether the given entity has not been killed, and is thus the current generation for this allocator.

More specifically, it checks whether the generation for the given entity is the current alive generation for that index. This generally means that the generation is too old because the Allocator allocated it and then later killed it, but it may also happen if Entitys are improperly mixed between Allocator instances and this entity has a newer generation than the current live one for that index.

pub fn entity(&self, index: Index) -> Option<Entity>

If the given index has a live entity associated with it, returns that live Entity.

pub fn allocate(&mut self) -> Entity

Allocate a new unique Entity.

pub fn allocate_atomic(&self) -> Entity

Allocate an entity atomically.

Atomically allocated entities are immediately valid, live entities indistinguishable from non-atomically allocated entities.

The only observable difference is that the query performance of atomically allocated entities may be slightly worse until merge_atomic is called, at which point they will be merged into the same data structure that keeps track of regular live entities.

pub fn live_bitset(&self) -> LiveBitSet<'_>

Returns a BitSetLike for all live entities.

This is a BitSetOr of the non-atomically live entities and the atomically live entities.

pub fn merge_atomic(&mut self, killed: &mut Vec<Entity>)

Merge all atomic operations done since the last call to Allocator::merge_atomic.

Atomically allocated entities become merged into the faster non-atomic BitSet, and entities marked for deletion with Allocator::kill_atomic actually become killed.

Takes a &mut Vec<Entity> parameter which will be cleared and filled with newly killed entities.

Trait Implementations

impl Debug for Allocator

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

Formats the value using the given formatter.

impl Default for Allocator

fn default() -> Allocator

Returns the "default value" for a type.

impl<'a> Join for &'a Allocator

type Item = Entity

type Access = &'a Allocator

type Mask = LiveBitSet<'a>

fn open(self) -> (Self::Mask, Self::Access)

unsafe fn get(access: &Self::Access, index: Index) -> Self::Item

Get a value out of the access type returned from open.