Simplifying the two wrapping version feature flags (entity and entity…

…_raw) to just one single wrapping_version flag

Cargo.toml

@@ -13,10 +13,8 @@ categories = ["data-structures", "game-engines"]
 [features]
 default = []
 32_components = []
-# Wrap rather than panic when an slot version overflows (used for entity handles).
-wrapping_entity_version = []
-# Wrap rather than panic when an archetype version overflows (used for raw entities).
-wrapping_entity_raw_version = []
+# Wrap rather than panic when a version number overflows (4,294,967,295 max)
+wrapping_version = []
 
 [dependencies]
 gecs_macros = { version = "0.3.0", path = "macros", default_features = false }

src/entity.rs

@@ -27,9 +27,9 @@ pub(crate) const ARCHETYPE_ID_BITS: u32 = ArchetypeId::BITS;
 /// By default, when this version overflows (i.e., a single entity slot
 /// was destroyed and reused for a new entity u32::MAX times), it will panic.
 /// If instead you would like to allow entity slot versions to wrap, you can
-/// enable the `wrapping_entity_version` crate feature instead. Note that this
-/// could allow invalid entity access, but doing so will not access invalid
-/// memory, and the chances of this happening are infinitesimally small.
+/// enable the `wrapping_version` crate feature instead. Note that this could
+/// allow invalid entity access, but doing so will not access invalid memory,
+/// and the chances of this happening are infinitesimally small.
 pub struct Entity<A: Archetype> {
     inner: EntityAny,
     _type: PhantomData<fn() -> A>,
@@ -49,9 +49,9 @@ pub struct Entity<A: Archetype> {
 /// By default, when this version overflows (i.e., an archetype has added or
 /// removed an entity `u32::MAX` times), it will cause a panic. If instead
 /// you would like to allow archetype versions to wrap, you can enable the
-/// `wrapping_entity_raw_version` crate feature instead. Note that this could
-/// allow invalid entity access, but doing so will not access invalid memory,
-/// and the chances of this happening are infinitesimally small.
+/// `wrapping_version` crate feature instead. Note that this could allow
+/// invalid entity access, but doing so will not access invalid memory, and
+/// the chances of this happening are infinitesimally small.
 pub struct EntityRaw<A: Archetype> {
     inner: EntityRawAny,
     _type: PhantomData<fn() -> A>,

src/version.rs

@@ -31,14 +31,10 @@ impl SlotVersion {
     #[inline(always)]
     pub(crate) fn next(&self) -> SlotVersion {
         SlotVersion {
-            #[cfg(feature = "wrapping_slot_version")]
-            version: NonZeroU32::new(u32::max(self.version.get().wrapping_add(1), VERSION_START))
-                .unwrap(),
-            #[cfg(not(feature = "wrapping_slot_version"))]
-            version: self
-                .version //.
-                .checked_add(1)
-                .expect("slot version overflow"),
+            #[cfg(feature = "wrapping_version")]
+            version: NonZeroU32::new(self.version.get().wrapping_add(1)).unwrap_or(VERSION_START),
+            #[cfg(not(feature = "wrapping_version"))]
+            version: self.version.checked_add(1).expect("slot version overflow"),
         }
     }
 }
@@ -59,14 +55,10 @@ impl ArchetypeVersion {
     #[inline(always)]
     pub(crate) fn next(&self) -> ArchetypeVersion {
         ArchetypeVersion {
-            #[cfg(feature = "wrapping_entity_raw_version")]
-            version: NonZeroU32::new(u32::max(self.version.get().wrapping_add(1), VERSION_START))
-                .unwrap(),
-            #[cfg(not(feature = "wrapping_entity_raw_version"))]
-            version: self
-                .version //.
-                .checked_add(1)
-                .expect("archetype version overflow"),
+            #[cfg(feature = "wrapping_version")]
+            version: NonZeroU32::new(self.version.get().wrapping_add(1)).unwrap_or(VERSION_START),
+            #[cfg(not(feature = "wrapping_version"))]
+            version: self.version.checked_add(1).expect("arch version overflow"),
         }
     }
 }