Struct EntityId 

pub struct EntityId {
    pub index: u32,
    pub generation: u32,
}

A unique identifier for an entity in the world.

It combines an index with a generation count to solve the “ABA problem”. When an entity is despawned, its index can be recycled for a new entity, but the generation is incremented. This ensures that old EntityId handles pointing to a recycled index become invalid and cannot accidentally affect the new entity.

Fields

index: u32

The index of the entity’s metadata in the central Vec<EntityMetadata>.

generation: u32

A generation counter that is incremented each time the index is recycled.

Trait Implementations

impl<'__de, __Context> BorrowDecode<'__de, __Context> for EntityId

fn borrow_decode<__D>(decoder: &mut __D) -> Result<EntityId, DecodeError>

where __D: BorrowDecoder<'__de, Context = __Context>,

Attempt to decode this type with the given BorrowDecode.

impl Clone for EntityId

fn clone(&self) -> EntityId

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EntityId

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

Formats the value using the given formatter.

impl<__Context> Decode<__Context> for EntityId

fn decode<__D>(decoder: &mut __D) -> Result<EntityId, DecodeError>

where __D: Decoder<Context = __Context>,

Attempt to decode this type with the given Decode.

impl<'de> Deserialize<'de> for EntityId

fn deserialize<__D>( __deserializer: __D, ) -> Result<EntityId, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for EntityId

fn encode<__E>(&self, encoder: &mut __E) -> Result<(), EncodeError>

where __E: Encoder,

Encode a given type.

impl Hash for EntityId

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for EntityId

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for EntityId

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl WorldQuery for EntityId

type Item<'a> = EntityId

The type of item that the query iterator will yield (e.g., (&'a Position, &'a mut Velocity)).

fn type_ids() -> Vec<TypeId>

Returns the sorted list of TypeIds for the components to be INCLUDED in the query. This signature is used to find ComponentPages that contain all these components.

unsafe fn fetch<'a>( page_ptr: *const ComponentPage, row_index: usize, ) -> <EntityId as WorldQuery>::Item<'a>

Fetches the query’s item from a specific row in a ComponentPage.

unsafe fn fetch_from_world<'a>( _world: *const World, entity_id: EntityId, ) -> Option<<EntityId as WorldQuery>::Item<'a>>

Fetches the query’s item directly from the world for a specific entity.

fn without_type_ids() -> Vec<TypeId>

Returns the sorted list of TypeIds for components to be EXCLUDED from the query. Used to filter out pages that contain these components.

impl Copy for EntityId

impl Eq for EntityId

impl StructuralPartialEq for EntityId