Struct EntityGeneration 

pub struct EntityGeneration(/* private fields */);

This tracks different versions or generations of an EntityIndex. Importantly, this can wrap, meaning each generation is not necessarily unique per EntityIndex.

This should be treated as a opaque identifier, and its internal representation may be subject to change.

Aliasing

Internally EntityGeneration wraps a u32, so it can’t represent every possible generation. Eventually, generations can (and do) wrap or alias. This can cause Entity and EntityGeneration values to be equal while still referring to different conceptual entities. This can cause some surprising behavior:

let (aliased, did_alias) = EntityGeneration::FIRST.after_versions(1u32 << 31).after_versions_and_could_alias(1u32 << 31);
assert!(did_alias);
assert!(EntityGeneration::FIRST == aliased);

This can cause some unintended side effects. See Entity docs for practical concerns and how to minimize any risks.

Implementations

impl EntityGeneration

pub const FIRST: EntityGeneration

Represents the first generation of an EntityIndex.

pub const fn to_bits(self) -> u32

Gets some bits that represent this value. The bits are opaque and should not be regarded as meaningful.

pub const fn from_bits(bits: u32) -> EntityGeneration

Reconstruct an EntityGeneration previously destructured with EntityGeneration::to_bits.

Only useful when applied to results from to_bits in the same instance of an application.

pub const fn after_versions(self, versions: u32) -> EntityGeneration

Returns the EntityGeneration that would result from this many more versions of the corresponding EntityIndex from passing.

pub const fn after_versions_and_could_alias( self, versions: u32, ) -> (EntityGeneration, bool)

Identical to after_versions but also returns a bool indicating if, after these versions, one such version could conflict with a previous one.

If this happens, this will no longer uniquely identify a version of an EntityIndex. This is called entity aliasing.

pub const fn cmp_approx(&self, other: &EntityGeneration) -> Ordering

Compares two generations.

Generations that are later will be Greater than earlier ones.

let later_generation = EntityGeneration::FIRST.after_versions(400);
assert_eq!(EntityGeneration::FIRST.cmp_approx(&later_generation), Ordering::Less);

let (aliased, did_alias) = EntityGeneration::FIRST.after_versions(400).after_versions_and_could_alias(u32::MAX);
assert!(did_alias);
assert_eq!(EntityGeneration::FIRST.cmp_approx(&aliased), Ordering::Less);

Ordering will be incorrect and non-transitive for distant generations:

let later_generation = EntityGeneration::FIRST.after_versions(3u32 << 31);
let much_later_generation = later_generation.after_versions(3u32 << 31);

// while these orderings are correct and pass assertions...
assert_eq!(EntityGeneration::FIRST.cmp_approx(&later_generation), Ordering::Less);
assert_eq!(later_generation.cmp_approx(&much_later_generation), Ordering::Less);

// ... this ordering is not and the assertion fails!
assert_eq!(EntityGeneration::FIRST.cmp_approx(&much_later_generation), Ordering::Less);

Because of this, EntityGeneration does not implement Ord/PartialOrd.

Trait Implementations

impl Clone for EntityGeneration

fn clone(&self) -> EntityGeneration

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EntityGeneration

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

Formats the value using the given formatter.

impl Display for EntityGeneration

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

Formats the value using the given formatter.

impl FromReflect for EntityGeneration

fn from_reflect( reflect: &(dyn PartialReflect + 'static), ) -> Option<EntityGeneration>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetTypeRegistration for EntityGeneration

fn get_type_registration() -> TypeRegistration

Returns the default [TypeRegistration] for this type.

fn register_type_dependencies(_registry: &mut TypeRegistry)

Registers other types needed by this type.

impl Hash for EntityGeneration

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 EntityGeneration

fn eq(&self, other: &EntityGeneration) -> 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 PartialReflect for EntityGeneration

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the [TypeInfo] of the type represented by this value.

fn to_dynamic(&self) -> Box<dyn PartialReflect>

Converts this reflected value into its dynamic representation based on its kind.

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<EntityGeneration>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<EntityGeneration>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect(self: Box<EntityGeneration>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

Casts this type to a mutable, reflected value.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

Returns a “partial equality” comparison result.

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

Debug formatter for the value.

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>

where T: 'static, Self: Sized + TypePath,

For a type implementing [PartialReflect], combines reflect_clone and take in a useful fashion, automatically constructing an appropriate [ReflectCloneError] if the downcast fails.

fn reflect_partial_cmp( &self, _value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

Returns a “partial comparison” result.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Reflect for EntityGeneration

fn into_any(self: Box<EntityGeneration>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<EntityGeneration>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

Casts this type to a mutable, fully-reflected value.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

impl TypePath for EntityGeneration

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for EntityGeneration

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Copy for EntityGeneration

impl Eq for EntityGeneration

impl StructuralPartialEq for EntityGeneration