forestia/bevy
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

use entity set collections type aliases instead of defaults (#18695)

Browse Source 
# Objective

Newest installment of the #16547 series.

In #18319 we introduced `Entity` defaults to accomodate the most common
use case for these types, however that resulted in the switch of the `T`
and `N` generics of `UniqueEntityArray`.
Swapping generics might be somewhat acceptable for `UniqueEntityArray`,
it is not at all acceptable for map and set types, which we would make
generic over `T: EntityEquivalent` in #18408.

Leaving these defaults in place would result in a glaring inconsistency
between these set collections and the others.

Additionally, the current standard in the engine is for "entity" to mean
`Entity`. APIs could be changed to accept `EntityEquivalent`, however
that is a separate and contentious discussion.

## Solution

Name these set collections `UniqueEntityEquivalent*`, and retain the
`UniqueEntity*` name for an alias of the `Entity` case.
While more verbose, this allows for all generics to be in proper order,
full consistency between all set types*, and the "entity" name to be
restricted to `Entity`.
On top of that, `UniqueEntity*` now always have 1 generic less, when
previously this was not enforced for the default case.

*`UniqueEntityIter<I: Iterator<T: EntityEquivalent>>` is the sole
exception to this. Aliases are unable to enforce bounds
(`lazy_type_alias` is needed for this), so for this type, doing this
split would be a mere suggestion, and in no way enforced.
Iterator types are rarely ever named, and this specific one is intended
to be aliased when it sees more use, like we do for the corresponding
set collection iterators.
Furthermore, the `EntityEquivalent` precursor `Borrow<Entity>` was used
exactly because of such iterator bounds!
Because of that, we leave it as is.

While no migration guide for 0.15 users, for those that upgrade from
main:
`UniqueEntityVec<T>` -> `UniqueEntityEquivalentVec<T>`
`UniqueEntitySlice<T>` -> `UniqueEntityEquivalentSlice<T>`
`UniqueEntityArray<N, T>` -> `UniqueEntityEquivalentArray<T, N>`
This commit is contained in:
Vic 2025-04-03 05:59:04 +02:00 committed by François Mockers
parent 2771803cbd
commit c9fb956058
8 changed files with 839 additions and 659 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
crates/bevy_ecs/src/entity/entity_set.rs
View File

@ -13,7 +13,7 @@ use core::{
option, result,
};
use super::{Entity, UniqueEntitySlice};
use super::{Entity, UniqueEntityEquivalentSlice};
use bevy_platform_support::sync::Arc;
@ -432,20 +432,20 @@ impl<T, I: Iterator<Item: EntityEquivalent> + AsRef<[T]>> AsRef<[T]> for UniqueE
}
impl<T: EntityEquivalent, I: Iterator<Item: EntityEquivalent> + AsRef<[T]>>
AsRef<UniqueEntitySlice<T>> for UniqueEntityIter<I>
AsRef<UniqueEntityEquivalentSlice<T>> for UniqueEntityIter<I>
{
fn as_ref(&self) -> &UniqueEntitySlice<T> {
fn as_ref(&self) -> &UniqueEntityEquivalentSlice<T> {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked(self.iter.as_ref()) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked(self.iter.as_ref()) }
}
}
impl<T: EntityEquivalent, I: Iterator<Item: EntityEquivalent> + AsMut<[T]>>
AsMut<UniqueEntitySlice<T>> for UniqueEntityIter<I>
AsMut<UniqueEntityEquivalentSlice<T>> for UniqueEntityIter<I>
{
fn as_mut(&mut self) -> &mut UniqueEntitySlice<T> {
fn as_mut(&mut self) -> &mut UniqueEntityEquivalentSlice<T> {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked_mut(self.iter.as_mut()) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked_mut(self.iter.as_mut()) }
}
}

6
crates/bevy_ecs/src/entity/mod.rs
View File

@ -67,9 +67,9 @@ pub mod unique_array;
pub mod unique_slice;
pub mod unique_vec;
pub use unique_array::UniqueEntityArray;
pub use unique_slice::UniqueEntitySlice;
pub use unique_vec::UniqueEntityVec;
pub use unique_array::{UniqueEntityArray, UniqueEntityEquivalentArray};
pub use unique_slice::{UniqueEntityEquivalentSlice, UniqueEntitySlice};
pub use unique_vec::{UniqueEntityEquivalentVec, UniqueEntityVec};
use crate::{
archetype::{ArchetypeId, ArchetypeRow},

347
crates/bevy_ecs/src/entity/unique_array.rs
View File

@ -21,19 +21,26 @@ use alloc::{
use bevy_platform_support::sync::Arc;
use super::{
unique_slice::{self, UniqueEntitySlice},
unique_slice::{self, UniqueEntityEquivalentSlice},
Entity, EntityEquivalent, UniqueEntityIter,
};
/// An array that contains only unique entities.
///
/// It can be obtained through certain methods on [`UniqueEntitySlice`],
/// It can be obtained through certain methods on [`UniqueEntityEquivalentSlice`],
/// and some [`TryFrom`] implementations.
///
/// When `T` is [`Entity`], use [`UniqueEntityArray`].
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
pub struct UniqueEntityArray<const N: usize, T: EntityEquivalent = Entity>([T; N]);
pub struct UniqueEntityEquivalentArray<T: EntityEquivalent, const N: usize>([T; N]);
impl<T: EntityEquivalent, const N: usize> UniqueEntityArray<N, T> {
/// Constructs a `UniqueEntityArray` from a [`[T; N]`] unsafely.
/// An array that contains only unique [`Entity`].
///
/// This is the default case of a [`UniqueEntityEquivalentArray`].
pub type UniqueEntityArray<const N: usize> = UniqueEntityEquivalentArray<Entity, N>;
impl<T: EntityEquivalent, const N: usize> UniqueEntityEquivalentArray<T, N> {
/// Constructs a `UniqueEntityEquivalentArray` from a [`[T; N]`] unsafely.
///
/// # Safety
///
@ -42,61 +49,61 @@ impl<T: EntityEquivalent, const N: usize> UniqueEntityArray<N, T> {
Self(array)
}
/// Constructs a `&UniqueEntityArray` from a [`&[T; N]`] unsafely.
/// Constructs a `&UniqueEntityEquivalentArray` from a [`&[T; N]`] unsafely.
///
/// # Safety
///
/// `array` must contain only unique elements.
pub const unsafe fn from_array_ref_unchecked(array: &[T; N]) -> &Self {
// SAFETY: UniqueEntityArray is a transparent wrapper around [T; N].
// SAFETY: UniqueEntityEquivalentArray is a transparent wrapper around [T; N].
unsafe { &*(ptr::from_ref(array).cast()) }
}
/// Constructs a `Box<UniqueEntityArray>` from a [`Box<[T; N]>`] unsafely.
/// Constructs a `Box<UniqueEntityEquivalentArray>` from a [`Box<[T; N]>`] unsafely.
///
/// # Safety
///
/// `array` must contain only unique elements.
pub unsafe fn from_boxed_array_unchecked(array: Box<[T; N]>) -> Box<Self> {
// SAFETY: UniqueEntityArray is a transparent wrapper around [T; N].
// SAFETY: UniqueEntityEquivalentArray is a transparent wrapper around [T; N].
unsafe { Box::from_raw(Box::into_raw(array).cast()) }
}
/// Casts `self` into the inner array.
pub fn into_boxed_inner(self: Box<Self>) -> Box<[T; N]> {
// SAFETY: UniqueEntityArray is a transparent wrapper around [T; N].
// SAFETY: UniqueEntityEquivalentArray is a transparent wrapper around [T; N].
unsafe { Box::from_raw(Box::into_raw(self).cast()) }
}
/// Constructs a `Arc<UniqueEntityArray>` from a [`Arc<[T; N]>`] unsafely.
/// Constructs a `Arc<UniqueEntityEquivalentArray>` from a [`Arc<[T; N]>`] unsafely.
///
/// # Safety
///
/// `slice` must contain only unique elements.
pub unsafe fn from_arc_array_unchecked(slice: Arc<[T; N]>) -> Arc<Self> {
// SAFETY: UniqueEntityArray is a transparent wrapper around [T; N].
// SAFETY: UniqueEntityEquivalentArray is a transparent wrapper around [T; N].
unsafe { Arc::from_raw(Arc::into_raw(slice).cast()) }
}
/// Casts `self` to the inner array.
pub fn into_arc_inner(this: Arc<Self>) -> Arc<[T; N]> {
// SAFETY: UniqueEntityArray is a transparent wrapper around [T; N].
// SAFETY: UniqueEntityEquivalentArray is a transparent wrapper around [T; N].
unsafe { Arc::from_raw(Arc::into_raw(this).cast()) }
}
// Constructs a `Rc<UniqueEntityArray>` from a [`Rc<[T; N]>`] unsafely.
// Constructs a `Rc<UniqueEntityEquivalentArray>` from a [`Rc<[T; N]>`] unsafely.
///
/// # Safety
///
/// `slice` must contain only unique elements.
pub unsafe fn from_rc_array_unchecked(slice: Rc<[T; N]>) -> Rc<Self> {
// SAFETY: UniqueEntityArray is a transparent wrapper around [T; N].
// SAFETY: UniqueEntityEquivalentArray is a transparent wrapper around [T; N].
unsafe { Rc::from_raw(Rc::into_raw(slice).cast()) }
}
/// Casts `self` to the inner array.
pub fn into_rc_inner(self: Rc<Self>) -> Rc<[T; N]> {
// SAFETY: UniqueEntityArray is a transparent wrapper around [T; N].
// SAFETY: UniqueEntityEquivalentArray is a transparent wrapper around [T; N].
unsafe { Rc::from_raw(Rc::into_raw(self).cast()) }
}
@ -111,49 +118,51 @@ impl<T: EntityEquivalent, const N: usize> UniqueEntityArray<N, T> {
}
/// Returns a slice containing the entire array. Equivalent to `&s[..]`.
pub const fn as_slice(&self) -> &UniqueEntitySlice<T> {
pub const fn as_slice(&self) -> &UniqueEntityEquivalentSlice<T> {
// SAFETY: All elements in the original array are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked(self.0.as_slice()) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked(self.0.as_slice()) }
}
/// Returns a mutable slice containing the entire array. Equivalent to
/// `&mut s[..]`.
pub fn as_mut_slice(&mut self) -> &mut UniqueEntitySlice<T> {
pub fn as_mut_slice(&mut self) -> &mut UniqueEntityEquivalentSlice<T> {
// SAFETY: All elements in the original array are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked_mut(self.0.as_mut_slice()) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked_mut(self.0.as_mut_slice()) }
}
/// Borrows each element and returns an array of references with the same
/// size as `self`.
///
/// Equivalent to [`[T; N]::as_ref`](array::each_ref).
pub fn each_ref(&self) -> UniqueEntityArray<N, &T> {
UniqueEntityArray(self.0.each_ref())
pub fn each_ref(&self) -> UniqueEntityEquivalentArray<&T, N> {
UniqueEntityEquivalentArray(self.0.each_ref())
}
}
impl<T: EntityEquivalent, const N: usize> Deref for UniqueEntityArray<N, T> {
type Target = UniqueEntitySlice<T>;
impl<T: EntityEquivalent, const N: usize> Deref for UniqueEntityEquivalentArray<T, N> {
type Target = UniqueEntityEquivalentSlice<T>;
fn deref(&self) -> &Self::Target {
// SAFETY: All elements in the original array are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked(&self.0) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked(&self.0) }
}
}
impl<T: EntityEquivalent, const N: usize> DerefMut for UniqueEntityArray<N, T> {
impl<T: EntityEquivalent, const N: usize> DerefMut for UniqueEntityEquivalentArray<T, N> {
fn deref_mut(&mut self) -> &mut Self::Target {
// SAFETY: All elements in the original array are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked_mut(&mut self.0) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked_mut(&mut self.0) }
}
}
impl<T: EntityEquivalent> Default for UniqueEntityArray<0, T> {
impl<T: EntityEquivalent> Default for UniqueEntityEquivalentArray<T, 0> {
fn default() -> Self {
Self(Default::default())
}
}
impl<'a, T: EntityEquivalent, const N: usize> IntoIterator for &'a UniqueEntityArray<N, T> {
impl<'a, T: EntityEquivalent, const N: usize> IntoIterator
for &'a UniqueEntityEquivalentArray<T, N>
{
type Item = &'a T;
type IntoIter = unique_slice::Iter<'a, T>;
@ -164,7 +173,7 @@ impl<'a, T: EntityEquivalent, const N: usize> IntoIterator for &'a UniqueEntityA
}
}
impl<T: EntityEquivalent, const N: usize> IntoIterator for UniqueEntityArray<N, T> {
impl<T: EntityEquivalent, const N: usize> IntoIterator for UniqueEntityEquivalentArray<T, N> {
type Item = T;
type IntoIter = IntoIter<N, T>;
@ -175,93 +184,107 @@ impl<T: EntityEquivalent, const N: usize> IntoIterator for UniqueEntityArray<N,
}
}
impl<T: EntityEquivalent, const N: usize> AsRef<UniqueEntitySlice<T>> for UniqueEntityArray<N, T> {
fn as_ref(&self) -> &UniqueEntitySlice<T> {
self
}
}
impl<T: EntityEquivalent, const N: usize> AsMut<UniqueEntitySlice<T>> for UniqueEntityArray<N, T> {
fn as_mut(&mut self) -> &mut UniqueEntitySlice<T> {
self
}
}
impl<T: EntityEquivalent, const N: usize> Borrow<UniqueEntitySlice<T>> for UniqueEntityArray<N, T> {
fn borrow(&self) -> &UniqueEntitySlice<T> {
self
}
}
impl<T: EntityEquivalent, const N: usize> BorrowMut<UniqueEntitySlice<T>>
for UniqueEntityArray<N, T>
impl<T: EntityEquivalent, const N: usize> AsRef<UniqueEntityEquivalentSlice<T>>
for UniqueEntityEquivalentArray<T, N>
{
fn borrow_mut(&mut self) -> &mut UniqueEntitySlice<T> {
fn as_ref(&self) -> &UniqueEntityEquivalentSlice<T> {
self
}
}
impl<T: EntityEquivalent, const N: usize> AsMut<UniqueEntityEquivalentSlice<T>>
for UniqueEntityEquivalentArray<T, N>
{
fn as_mut(&mut self) -> &mut UniqueEntityEquivalentSlice<T> {
self
}
}
impl<T: EntityEquivalent, const N: usize> Borrow<UniqueEntityEquivalentSlice<T>>
for UniqueEntityEquivalentArray<T, N>
{
fn borrow(&self) -> &UniqueEntityEquivalentSlice<T> {
self
}
}
impl<T: EntityEquivalent, const N: usize> BorrowMut<UniqueEntityEquivalentSlice<T>>
for UniqueEntityEquivalentArray<T, N>
{
fn borrow_mut(&mut self) -> &mut UniqueEntityEquivalentSlice<T> {
self
}
}
impl<T: EntityEquivalent, const N: usize> Index<(Bound<usize>, Bound<usize>)>
for UniqueEntityArray<N, T>
for UniqueEntityEquivalentArray<T, N>
{
type Output = UniqueEntitySlice<T>;
type Output = UniqueEntityEquivalentSlice<T>;
fn index(&self, key: (Bound<usize>, Bound<usize>)) -> &Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked(self.0.index(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked(self.0.index(key)) }
}
}
impl<T: EntityEquivalent, const N: usize> Index<Range<usize>> for UniqueEntityArray<N, T> {
type Output = UniqueEntitySlice<T>;
impl<T: EntityEquivalent, const N: usize> Index<Range<usize>>
for UniqueEntityEquivalentArray<T, N>
{
type Output = UniqueEntityEquivalentSlice<T>;
fn index(&self, key: Range<usize>) -> &Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked(self.0.index(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked(self.0.index(key)) }
}
}
impl<T: EntityEquivalent, const N: usize> Index<RangeFrom<usize>> for UniqueEntityArray<N, T> {
type Output = UniqueEntitySlice<T>;
impl<T: EntityEquivalent, const N: usize> Index<RangeFrom<usize>>
for UniqueEntityEquivalentArray<T, N>
{
type Output = UniqueEntityEquivalentSlice<T>;
fn index(&self, key: RangeFrom<usize>) -> &Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked(self.0.index(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked(self.0.index(key)) }
}
}
impl<T: EntityEquivalent, const N: usize> Index<RangeFull> for UniqueEntityArray<N, T> {
type Output = UniqueEntitySlice<T>;
impl<T: EntityEquivalent, const N: usize> Index<RangeFull> for UniqueEntityEquivalentArray<T, N> {
type Output = UniqueEntityEquivalentSlice<T>;
fn index(&self, key: RangeFull) -> &Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked(self.0.index(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked(self.0.index(key)) }
}
}
impl<T: EntityEquivalent, const N: usize> Index<RangeInclusive<usize>> for UniqueEntityArray<N, T> {
type Output = UniqueEntitySlice<T>;
impl<T: EntityEquivalent, const N: usize> Index<RangeInclusive<usize>>
for UniqueEntityEquivalentArray<T, N>
{
type Output = UniqueEntityEquivalentSlice<T>;
fn index(&self, key: RangeInclusive<usize>) -> &Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked(self.0.index(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked(self.0.index(key)) }
}
}
impl<T: EntityEquivalent, const N: usize> Index<RangeTo<usize>> for UniqueEntityArray<N, T> {
type Output = UniqueEntitySlice<T>;
impl<T: EntityEquivalent, const N: usize> Index<RangeTo<usize>>
for UniqueEntityEquivalentArray<T, N>
{
type Output = UniqueEntityEquivalentSlice<T>;
fn index(&self, key: RangeTo<usize>) -> &Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked(self.0.index(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked(self.0.index(key)) }
}
}
impl<T: EntityEquivalent, const N: usize> Index<RangeToInclusive<usize>>
for UniqueEntityArray<N, T>
for UniqueEntityEquivalentArray<T, N>
{
type Output = UniqueEntitySlice<T>;
type Output = UniqueEntityEquivalentSlice<T>;
fn index(&self, key: RangeToInclusive<usize>) -> &Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked(self.0.index(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked(self.0.index(key)) }
}
}
impl<T: EntityEquivalent, const N: usize> Index<usize> for UniqueEntityArray<N, T> {
impl<T: EntityEquivalent, const N: usize> Index<usize> for UniqueEntityEquivalentArray<T, N> {
type Output = T;
fn index(&self, key: usize) -> &T {
self.0.index(key)
@ -269,248 +292,268 @@ impl<T: EntityEquivalent, const N: usize> Index<usize> for UniqueEntityArray<N,
}
impl<T: EntityEquivalent, const N: usize> IndexMut<(Bound<usize>, Bound<usize>)>
for UniqueEntityArray<N, T>
for UniqueEntityEquivalentArray<T, N>
{
fn index_mut(&mut self, key: (Bound<usize>, Bound<usize>)) -> &mut Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
}
}
impl<T: EntityEquivalent, const N: usize> IndexMut<Range<usize>> for UniqueEntityArray<N, T> {
impl<T: EntityEquivalent, const N: usize> IndexMut<Range<usize>>
for UniqueEntityEquivalentArray<T, N>
{
fn index_mut(&mut self, key: Range<usize>) -> &mut Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
}
}
impl<T: EntityEquivalent, const N: usize> IndexMut<RangeFrom<usize>> for UniqueEntityArray<N, T> {
impl<T: EntityEquivalent, const N: usize> IndexMut<RangeFrom<usize>>
for UniqueEntityEquivalentArray<T, N>
{
fn index_mut(&mut self, key: RangeFrom<usize>) -> &mut Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
}
}
impl<T: EntityEquivalent, const N: usize> IndexMut<RangeFull> for UniqueEntityArray<N, T> {
impl<T: EntityEquivalent, const N: usize> IndexMut<RangeFull>
for UniqueEntityEquivalentArray<T, N>
{
fn index_mut(&mut self, key: RangeFull) -> &mut Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
}
}
impl<T: EntityEquivalent, const N: usize> IndexMut<RangeInclusive<usize>>
for UniqueEntityArray<N, T>
for UniqueEntityEquivalentArray<T, N>
{
fn index_mut(&mut self, key: RangeInclusive<usize>) -> &mut Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
}
}
impl<T: EntityEquivalent, const N: usize> IndexMut<RangeTo<usize>> for UniqueEntityArray<N, T> {
impl<T: EntityEquivalent, const N: usize> IndexMut<RangeTo<usize>>
for UniqueEntityEquivalentArray<T, N>
{
fn index_mut(&mut self, key: RangeTo<usize>) -> &mut Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
}
}
impl<T: EntityEquivalent, const N: usize> IndexMut<RangeToInclusive<usize>>
for UniqueEntityArray<N, T>
for UniqueEntityEquivalentArray<T, N>
{
fn index_mut(&mut self, key: RangeToInclusive<usize>) -> &mut Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
}
}
impl<T: EntityEquivalent + Clone> From<&[T; 1]> for UniqueEntityArray<1, T> {
impl<T: EntityEquivalent + Clone> From<&[T; 1]> for UniqueEntityEquivalentArray<T, 1> {
fn from(value: &[T; 1]) -> Self {
Self(value.clone())
}
}
impl<T: EntityEquivalent + Clone> From<&[T; 0]> for UniqueEntityArray<0, T> {
impl<T: EntityEquivalent + Clone> From<&[T; 0]> for UniqueEntityEquivalentArray<T, 0> {
fn from(value: &[T; 0]) -> Self {
Self(value.clone())
}
}
impl<T: EntityEquivalent + Clone> From<&mut [T; 1]> for UniqueEntityArray<1, T> {
impl<T: EntityEquivalent + Clone> From<&mut [T; 1]> for UniqueEntityEquivalentArray<T, 1> {
fn from(value: &mut [T; 1]) -> Self {
Self(value.clone())
}
}
impl<T: EntityEquivalent + Clone> From<&mut [T; 0]> for UniqueEntityArray<0, T> {
impl<T: EntityEquivalent + Clone> From<&mut [T; 0]> for UniqueEntityEquivalentArray<T, 0> {
fn from(value: &mut [T; 0]) -> Self {
Self(value.clone())
}
}
impl<T: EntityEquivalent> From<[T; 1]> for UniqueEntityArray<1, T> {
impl<T: EntityEquivalent> From<[T; 1]> for UniqueEntityEquivalentArray<T, 1> {
fn from(value: [T; 1]) -> Self {
Self(value)
}
}
impl<T: EntityEquivalent> From<[T; 0]> for UniqueEntityArray<0, T> {
impl<T: EntityEquivalent> From<[T; 0]> for UniqueEntityEquivalentArray<T, 0> {
fn from(value: [T; 0]) -> Self {
Self(value)
}
}
impl<T: EntityEquivalent> From<UniqueEntityArray<1, T>> for (T,) {
fn from(array: UniqueEntityArray<1, T>) -> Self {
impl<T: EntityEquivalent> From<UniqueEntityEquivalentArray<T, 1>> for (T,) {
fn from(array: UniqueEntityEquivalentArray<T, 1>) -> Self {
Self::from(array.into_inner())
}
}
impl<T: EntityEquivalent> From<UniqueEntityArray<2, T>> for (T, T) {
fn from(array: UniqueEntityArray<2, T>) -> Self {
impl<T: EntityEquivalent> From<UniqueEntityEquivalentArray<T, 2>> for (T, T) {
fn from(array: UniqueEntityEquivalentArray<T, 2>) -> Self {
Self::from(array.into_inner())
}
}
impl<T: EntityEquivalent> From<UniqueEntityArray<3, T>> for (T, T, T) {
fn from(array: UniqueEntityArray<3, T>) -> Self {
impl<T: EntityEquivalent> From<UniqueEntityEquivalentArray<T, 3>> for (T, T, T) {
fn from(array: UniqueEntityEquivalentArray<T, 3>) -> Self {
Self::from(array.into_inner())
}
}
impl<T: EntityEquivalent> From<UniqueEntityArray<4, T>> for (T, T, T, T) {
fn from(array: UniqueEntityArray<4, T>) -> Self {
impl<T: EntityEquivalent> From<UniqueEntityEquivalentArray<T, 4>> for (T, T, T, T) {
fn from(array: UniqueEntityEquivalentArray<T, 4>) -> Self {
Self::from(array.into_inner())
}
}
impl<T: EntityEquivalent> From<UniqueEntityArray<5, T>> for (T, T, T, T, T) {
fn from(array: UniqueEntityArray<5, T>) -> Self {
impl<T: EntityEquivalent> From<UniqueEntityEquivalentArray<T, 5>> for (T, T, T, T, T) {
fn from(array: UniqueEntityEquivalentArray<T, 5>) -> Self {
Self::from(array.into_inner())
}
}
impl<T: EntityEquivalent> From<UniqueEntityArray<6, T>> for (T, T, T, T, T, T) {
fn from(array: UniqueEntityArray<6, T>) -> Self {
impl<T: EntityEquivalent> From<UniqueEntityEquivalentArray<T, 6>> for (T, T, T, T, T, T) {
fn from(array: UniqueEntityEquivalentArray<T, 6>) -> Self {
Self::from(array.into_inner())
}
}
impl<T: EntityEquivalent> From<UniqueEntityArray<7, T>> for (T, T, T, T, T, T, T) {
fn from(array: UniqueEntityArray<7, T>) -> Self {
impl<T: EntityEquivalent> From<UniqueEntityEquivalentArray<T, 7>> for (T, T, T, T, T, T, T) {
fn from(array: UniqueEntityEquivalentArray<T, 7>) -> Self {
Self::from(array.into_inner())
}
}
impl<T: EntityEquivalent> From<UniqueEntityArray<8, T>> for (T, T, T, T, T, T, T, T) {
fn from(array: UniqueEntityArray<8, T>) -> Self {
impl<T: EntityEquivalent> From<UniqueEntityEquivalentArray<T, 8>> for (T, T, T, T, T, T, T, T) {
fn from(array: UniqueEntityEquivalentArray<T, 8>) -> Self {
Self::from(array.into_inner())
}
}
impl<T: EntityEquivalent> From<UniqueEntityArray<9, T>> for (T, T, T, T, T, T, T, T, T) {
fn from(array: UniqueEntityArray<9, T>) -> Self {
impl<T: EntityEquivalent> From<UniqueEntityEquivalentArray<T, 9>> for (T, T, T, T, T, T, T, T, T) {
fn from(array: UniqueEntityEquivalentArray<T, 9>) -> Self {
Self::from(array.into_inner())
}
}
impl<T: EntityEquivalent> From<UniqueEntityArray<10, T>> for (T, T, T, T, T, T, T, T, T, T) {
fn from(array: UniqueEntityArray<10, T>) -> Self {
impl<T: EntityEquivalent> From<UniqueEntityEquivalentArray<T, 10>>
for (T, T, T, T, T, T, T, T, T, T)
{
fn from(array: UniqueEntityEquivalentArray<T, 10>) -> Self {
Self::from(array.into_inner())
}
}
impl<T: EntityEquivalent> From<UniqueEntityArray<11, T>> for (T, T, T, T, T, T, T, T, T, T, T) {
fn from(array: UniqueEntityArray<11, T>) -> Self {
impl<T: EntityEquivalent> From<UniqueEntityEquivalentArray<T, 11>>
for (T, T, T, T, T, T, T, T, T, T, T)
{
fn from(array: UniqueEntityEquivalentArray<T, 11>) -> Self {
Self::from(array.into_inner())
}
}
impl<T: EntityEquivalent> From<UniqueEntityArray<12, T>> for (T, T, T, T, T, T, T, T, T, T, T, T) {
fn from(array: UniqueEntityArray<12, T>) -> Self {
impl<T: EntityEquivalent> From<UniqueEntityEquivalentArray<T, 12>>
for (T, T, T, T, T, T, T, T, T, T, T, T)
{
fn from(array: UniqueEntityEquivalentArray<T, 12>) -> Self {
Self::from(array.into_inner())
}
}
impl<T: EntityEquivalent + Ord, const N: usize> From<UniqueEntityArray<N, T>> for BTreeSet<T> {
fn from(value: UniqueEntityArray<N, T>) -> Self {
impl<T: EntityEquivalent + Ord, const N: usize> From<UniqueEntityEquivalentArray<T, N>>
for BTreeSet<T>
{
fn from(value: UniqueEntityEquivalentArray<T, N>) -> Self {
BTreeSet::from(value.0)
}
}
impl<T: EntityEquivalent + Ord, const N: usize> From<UniqueEntityArray<N, T>> for BinaryHeap<T> {
fn from(value: UniqueEntityArray<N, T>) -> Self {
impl<T: EntityEquivalent + Ord, const N: usize> From<UniqueEntityEquivalentArray<T, N>>
for BinaryHeap<T>
{
fn from(value: UniqueEntityEquivalentArray<T, N>) -> Self {
BinaryHeap::from(value.0)
}
}
impl<T: EntityEquivalent, const N: usize> From<UniqueEntityArray<N, T>> for LinkedList<T> {
fn from(value: UniqueEntityArray<N, T>) -> Self {
impl<T: EntityEquivalent, const N: usize> From<UniqueEntityEquivalentArray<T, N>>
for LinkedList<T>
{
fn from(value: UniqueEntityEquivalentArray<T, N>) -> Self {
LinkedList::from(value.0)
}
}
impl<T: EntityEquivalent, const N: usize> From<UniqueEntityArray<N, T>> for Vec<T> {
fn from(value: UniqueEntityArray<N, T>) -> Self {
impl<T: EntityEquivalent, const N: usize> From<UniqueEntityEquivalentArray<T, N>> for Vec<T> {
fn from(value: UniqueEntityEquivalentArray<T, N>) -> Self {
Vec::from(value.0)
}
}
impl<T: EntityEquivalent, const N: usize> From<UniqueEntityArray<N, T>> for VecDeque<T> {
fn from(value: UniqueEntityArray<N, T>) -> Self {
impl<T: EntityEquivalent, const N: usize> From<UniqueEntityEquivalentArray<T, N>> for VecDeque<T> {
fn from(value: UniqueEntityEquivalentArray<T, N>) -> Self {
VecDeque::from(value.0)
}
}
impl<T: EntityEquivalent + PartialEq<U>, U: EntityEquivalent, const N: usize>
PartialEq<&UniqueEntitySlice<U>> for UniqueEntityArray<N, T>
PartialEq<&UniqueEntityEquivalentSlice<U>> for UniqueEntityEquivalentArray<T, N>
{
fn eq(&self, other: &&UniqueEntitySlice<U>) -> bool {
fn eq(&self, other: &&UniqueEntityEquivalentSlice<U>) -> bool {
self.0.eq(&other.as_inner())
}
}
impl<T: EntityEquivalent + PartialEq<U>, U: EntityEquivalent, const N: usize>
PartialEq<UniqueEntitySlice<U>> for UniqueEntityArray<N, T>
PartialEq<UniqueEntityEquivalentSlice<U>> for UniqueEntityEquivalentArray<T, N>
{
fn eq(&self, other: &UniqueEntitySlice<U>) -> bool {
fn eq(&self, other: &UniqueEntityEquivalentSlice<U>) -> bool {
self.0.eq(other.as_inner())
}
}
impl<T: PartialEq<U>, U: EntityEquivalent, const N: usize> PartialEq<&UniqueEntityArray<N, U>>
for Vec<T>
impl<T: PartialEq<U>, U: EntityEquivalent, const N: usize>
PartialEq<&UniqueEntityEquivalentArray<U, N>> for Vec<T>
{
fn eq(&self, other: &&UniqueEntityArray<N, U>) -> bool {
fn eq(&self, other: &&UniqueEntityEquivalentArray<U, N>) -> bool {
self.eq(&other.0)
}
}
impl<T: PartialEq<U>, U: EntityEquivalent, const N: usize> PartialEq<&UniqueEntityArray<N, U>>
for VecDeque<T>
impl<T: PartialEq<U>, U: EntityEquivalent, const N: usize>
PartialEq<&UniqueEntityEquivalentArray<U, N>> for VecDeque<T>
{
fn eq(&self, other: &&UniqueEntityArray<N, U>) -> bool {
fn eq(&self, other: &&UniqueEntityEquivalentArray<U, N>) -> bool {
self.eq(&other.0)
}
}
impl<T: PartialEq<U>, U: EntityEquivalent, const N: usize> PartialEq<&mut UniqueEntityArray<N, U>>
for VecDeque<T>
impl<T: PartialEq<U>, U: EntityEquivalent, const N: usize>
PartialEq<&mut UniqueEntityEquivalentArray<U, N>> for VecDeque<T>
{
fn eq(&self, other: &&mut UniqueEntityArray<N, U>) -> bool {
fn eq(&self, other: &&mut UniqueEntityEquivalentArray<U, N>) -> bool {
self.eq(&other.0)
}
}
impl<T: PartialEq<U>, U: EntityEquivalent, const N: usize> PartialEq<UniqueEntityArray<N, U>>
for Vec<T>
impl<T: PartialEq<U>, U: EntityEquivalent, const N: usize>
PartialEq<UniqueEntityEquivalentArray<U, N>> for Vec<T>
{
fn eq(&self, other: &UniqueEntityArray<N, U>) -> bool {
fn eq(&self, other: &UniqueEntityEquivalentArray<U, N>) -> bool {
self.eq(&other.0)
}
}
impl<T: PartialEq<U>, U: EntityEquivalent, const N: usize> PartialEq<UniqueEntityArray<N, U>>
for VecDeque<T>
impl<T: PartialEq<U>, U: EntityEquivalent, const N: usize>
PartialEq<UniqueEntityEquivalentArray<U, N>> for VecDeque<T>
{
fn eq(&self, other: &UniqueEntityArray<N, U>) -> bool {
fn eq(&self, other: &UniqueEntityEquivalentArray<U, N>) -> bool {
self.eq(&other.0)
}
}
@ -525,16 +568,20 @@ impl<T: EntityEquivalent, const N: usize> UniqueEntityIter<array::IntoIter<T, N>
/// yet.
///
/// Equivalent to [`array::IntoIter::as_slice`].
pub fn as_slice(&self) -> &UniqueEntitySlice<T> {
pub fn as_slice(&self) -> &UniqueEntityEquivalentSlice<T> {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked(self.as_inner().as_slice()) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked(self.as_inner().as_slice()) }
}
/// Returns a mutable slice of all elements that have not been yielded yet.
///
/// Equivalent to [`array::IntoIter::as_mut_slice`].
pub fn as_mut_slice(&mut self) -> &mut UniqueEntitySlice<T> {
pub fn as_mut_slice(&mut self) -> &mut UniqueEntityEquivalentSlice<T> {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked_mut(self.as_mut_inner().as_mut_slice()) }
unsafe {
UniqueEntityEquivalentSlice::from_slice_unchecked_mut(
self.as_mut_inner().as_mut_slice(),
)
}
}
}

697
crates/bevy_ecs/src/entity/unique_slice.rs
View File

File diff suppressed because it is too large Load Diff

422
crates/bevy_ecs/src/entity/unique_vec.rs
View File

@ -20,8 +20,8 @@ use alloc::{
use bevy_platform_support::sync::Arc;
use super::{
unique_slice::{self, UniqueEntitySlice},
Entity, EntityEquivalent, EntitySet, FromEntitySetIterator, UniqueEntityArray,
unique_slice::{self, UniqueEntityEquivalentSlice},
Entity, EntityEquivalent, EntitySet, FromEntitySetIterator, UniqueEntityEquivalentArray,
UniqueEntityIter,
};
@ -31,29 +31,36 @@ use super::{
/// This is always true when less than 2 entities are present.
///
/// This type is best obtained by its `FromEntitySetIterator` impl, via either
/// `EntityIterator::collect_set` or `UniqueEntityVec::from_entity_iter`.
/// `EntityIterator::collect_set` or `UniqueEntityEquivalentVec::from_entity_iter`.
///
/// While this type can be constructed via `Iterator::collect`, doing so is inefficient,
/// and not recommended.
///
/// When `T` is [`Entity`], use the [`UniqueEntityVec`] alias.
#[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
pub struct UniqueEntityVec<T: EntityEquivalent = Entity>(Vec<T>);
pub struct UniqueEntityEquivalentVec<T: EntityEquivalent>(Vec<T>);
impl<T: EntityEquivalent> UniqueEntityVec<T> {
/// Constructs a new, empty `UniqueEntityVec<T>`.
/// A `Vec` that contains only unique [`Entity`].
///
/// This is the default case of a [`UniqueEntityEquivalentVec`].
pub type UniqueEntityVec = UniqueEntityEquivalentVec<Entity>;
impl<T: EntityEquivalent> UniqueEntityEquivalentVec<T> {
/// Constructs a new, empty `UniqueEntityEquivalentVec<T>`.
///
/// Equivalent to [`Vec::new`].
pub const fn new() -> Self {
Self(Vec::new())
}
/// Constructs a new, empty `UniqueEntityVec<T>` with at least the specified capacity.
/// Constructs a new, empty `UniqueEntityEquivalentVec<T>` with at least the specified capacity.
///
/// Equivalent to [`Vec::with_capacity`]
pub fn with_capacity(capacity: usize) -> Self {
Self(Vec::with_capacity(capacity))
}
/// Creates a `UniqueEntityVec<T>` directly from a pointer, a length, and a capacity.
/// Creates a `UniqueEntityEquivalentVec<T>` directly from a pointer, a length, and a capacity.
///
/// Equivalent to [`Vec::from_raw_parts`].
///
@ -66,7 +73,7 @@ impl<T: EntityEquivalent> UniqueEntityVec<T> {
Self(unsafe { Vec::from_raw_parts(ptr, length, capacity) })
}
/// Constructs a `UniqueEntityVec` from a [`Vec<T>`] unsafely.
/// Constructs a `UniqueEntityEquivalentVec` from a [`Vec<T>`] unsafely.
///
/// # Safety
///
@ -112,7 +119,7 @@ impl<T: EntityEquivalent> UniqueEntityVec<T> {
}
/// Reserves the minimum capacity for at least `additional` more elements to
/// be inserted in the given `UniqueEntityVec<T>`.
/// be inserted in the given `UniqueEntityEquivalentVec<T>`.
///
/// Equivalent to [`Vec::reserve_exact`].
pub fn reserve_exact(&mut self, additional: usize) {
@ -149,19 +156,21 @@ impl<T: EntityEquivalent> UniqueEntityVec<T> {
self.0.shrink_to(min_capacity);
}
/// Converts the vector into `Box<UniqueEntitySlice<T>>`.
pub fn into_boxed_slice(self) -> Box<UniqueEntitySlice<T>> {
// SAFETY: UniqueEntitySlice is a transparent wrapper around [T].
unsafe { UniqueEntitySlice::from_boxed_slice_unchecked(self.0.into_boxed_slice()) }
/// Converts the vector into `Box<UniqueEntityEquivalentSlice<T>>`.
pub fn into_boxed_slice(self) -> Box<UniqueEntityEquivalentSlice<T>> {
// SAFETY: UniqueEntityEquivalentSlice is a transparent wrapper around [T].
unsafe {
UniqueEntityEquivalentSlice::from_boxed_slice_unchecked(self.0.into_boxed_slice())
}
}
/// Extracts a slice containing the entire vector.
pub fn as_slice(&self) -> &UniqueEntitySlice<T> {
pub fn as_slice(&self) -> &UniqueEntityEquivalentSlice<T> {
self
}
/// Extracts a mutable slice of the entire vector.
pub fn as_mut_slice(&mut self) -> &mut UniqueEntitySlice<T> {
pub fn as_mut_slice(&mut self) -> &mut UniqueEntityEquivalentSlice<T> {
self
}
@ -301,7 +310,7 @@ impl<T: EntityEquivalent> UniqueEntityVec<T> {
/// # Safety
///
/// `other` must contain no elements that equal any element in `self`.
pub unsafe fn append(&mut self, other: &mut UniqueEntityVec<T>) {
pub unsafe fn append(&mut self, other: &mut UniqueEntityEquivalentVec<T>) {
self.0.append(&mut other.0);
}
@ -368,10 +377,10 @@ impl<T: EntityEquivalent> UniqueEntityVec<T> {
self.0.resize_with(new_len, f);
}
/// Consumes and leaks the Vec, returning a mutable reference to the contents, `&'a mut UniqueEntitySlice<T>`.
pub fn leak<'a>(self) -> &'a mut UniqueEntitySlice<T> {
/// Consumes and leaks the Vec, returning a mutable reference to the contents, `&'a mut UniqueEntityEquivalentSlice<T>`.
pub fn leak<'a>(self) -> &'a mut UniqueEntityEquivalentSlice<T> {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked_mut(self.0.leak()) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked_mut(self.0.leak()) }
}
/// Returns the remaining spare capacity of the vector as a slice of
@ -405,29 +414,29 @@ impl<T: EntityEquivalent> UniqueEntityVec<T> {
}
}
impl<T: EntityEquivalent> Default for UniqueEntityVec<T> {
impl<T: EntityEquivalent> Default for UniqueEntityEquivalentVec<T> {
fn default() -> Self {
Self(Vec::default())
}
}
impl<T: EntityEquivalent> Deref for UniqueEntityVec<T> {
type Target = UniqueEntitySlice<T>;
impl<T: EntityEquivalent> Deref for UniqueEntityEquivalentVec<T> {
type Target = UniqueEntityEquivalentSlice<T>;
fn deref(&self) -> &Self::Target {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked(&self.0) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked(&self.0) }
}
}
impl<T: EntityEquivalent> DerefMut for UniqueEntityVec<T> {
impl<T: EntityEquivalent> DerefMut for UniqueEntityEquivalentVec<T> {
fn deref_mut(&mut self) -> &mut Self::Target {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked_mut(&mut self.0) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked_mut(&mut self.0) }
}
}
impl<'a, T: EntityEquivalent> IntoIterator for &'a UniqueEntityVec<T>
impl<'a, T: EntityEquivalent> IntoIterator for &'a UniqueEntityEquivalentVec<T>
where
&'a T: EntityEquivalent,
{
@ -441,7 +450,7 @@ where
}
}
impl<T: EntityEquivalent> IntoIterator for UniqueEntityVec<T> {
impl<T: EntityEquivalent> IntoIterator for UniqueEntityEquivalentVec<T> {
type Item = T;
type IntoIter = IntoIter<T>;
@ -452,102 +461,104 @@ impl<T: EntityEquivalent> IntoIterator for UniqueEntityVec<T> {
}
}
impl<T: EntityEquivalent> AsMut<Self> for UniqueEntityVec<T> {
fn as_mut(&mut self) -> &mut UniqueEntityVec<T> {
impl<T: EntityEquivalent> AsMut<Self> for UniqueEntityEquivalentVec<T> {
fn as_mut(&mut self) -> &mut UniqueEntityEquivalentVec<T> {
self
}
}
impl<T: EntityEquivalent> AsMut<UniqueEntitySlice<T>> for UniqueEntityVec<T> {
fn as_mut(&mut self) -> &mut UniqueEntitySlice<T> {
impl<T: EntityEquivalent> AsMut<UniqueEntityEquivalentSlice<T>> for UniqueEntityEquivalentVec<T> {
fn as_mut(&mut self) -> &mut UniqueEntityEquivalentSlice<T> {
self
}
}
impl<T: EntityEquivalent> AsRef<Self> for UniqueEntityVec<T> {
impl<T: EntityEquivalent> AsRef<Self> for UniqueEntityEquivalentVec<T> {
fn as_ref(&self) -> &Self {
self
}
}
impl<T: EntityEquivalent> AsRef<Vec<T>> for UniqueEntityVec<T> {
impl<T: EntityEquivalent> AsRef<Vec<T>> for UniqueEntityEquivalentVec<T> {
fn as_ref(&self) -> &Vec<T> {
&self.0
}
}
impl<T: EntityEquivalent> Borrow<Vec<T>> for UniqueEntityVec<T> {
impl<T: EntityEquivalent> Borrow<Vec<T>> for UniqueEntityEquivalentVec<T> {
fn borrow(&self) -> &Vec<T> {
&self.0
}
}
impl<T: EntityEquivalent> AsRef<[T]> for UniqueEntityVec<T> {
impl<T: EntityEquivalent> AsRef<[T]> for UniqueEntityEquivalentVec<T> {
fn as_ref(&self) -> &[T] {
&self.0
}
}
impl<T: EntityEquivalent> AsRef<UniqueEntitySlice<T>> for UniqueEntityVec<T> {
fn as_ref(&self) -> &UniqueEntitySlice<T> {
impl<T: EntityEquivalent> AsRef<UniqueEntityEquivalentSlice<T>> for UniqueEntityEquivalentVec<T> {
fn as_ref(&self) -> &UniqueEntityEquivalentSlice<T> {
self
}
}
impl<T: EntityEquivalent> Borrow<[T]> for UniqueEntityVec<T> {
impl<T: EntityEquivalent> Borrow<[T]> for UniqueEntityEquivalentVec<T> {
fn borrow(&self) -> &[T] {
&self.0
}
}
impl<T: EntityEquivalent> Borrow<UniqueEntitySlice<T>> for UniqueEntityVec<T> {
fn borrow(&self) -> &UniqueEntitySlice<T> {
impl<T: EntityEquivalent> Borrow<UniqueEntityEquivalentSlice<T>> for UniqueEntityEquivalentVec<T> {
fn borrow(&self) -> &UniqueEntityEquivalentSlice<T> {
self
}
}
impl<T: EntityEquivalent> BorrowMut<UniqueEntitySlice<T>> for UniqueEntityVec<T> {
fn borrow_mut(&mut self) -> &mut UniqueEntitySlice<T> {
impl<T: EntityEquivalent> BorrowMut<UniqueEntityEquivalentSlice<T>>
for UniqueEntityEquivalentVec<T>
{
fn borrow_mut(&mut self) -> &mut UniqueEntityEquivalentSlice<T> {
self
}
}
impl<T: EntityEquivalent + PartialEq<U>, U> PartialEq<Vec<U>> for UniqueEntityVec<T> {
impl<T: EntityEquivalent + PartialEq<U>, U> PartialEq<Vec<U>> for UniqueEntityEquivalentVec<T> {
fn eq(&self, other: &Vec<U>) -> bool {
self.0.eq(other)
}
}
impl<T: EntityEquivalent + PartialEq<U>, U> PartialEq<&[U]> for UniqueEntityVec<T> {
impl<T: EntityEquivalent + PartialEq<U>, U> PartialEq<&[U]> for UniqueEntityEquivalentVec<T> {
fn eq(&self, other: &&[U]) -> bool {
self.0.eq(other)
}
}
impl<T: EntityEquivalent + PartialEq<U>, U: EntityEquivalent> PartialEq<&UniqueEntitySlice<U>>
for UniqueEntityVec<T>
impl<T: EntityEquivalent + PartialEq<U>, U: EntityEquivalent>
PartialEq<&UniqueEntityEquivalentSlice<U>> for UniqueEntityEquivalentVec<T>
{
fn eq(&self, other: &&UniqueEntitySlice<U>) -> bool {
fn eq(&self, other: &&UniqueEntityEquivalentSlice<U>) -> bool {
self.0.eq(other)
}
}
impl<T: EntityEquivalent + PartialEq<U>, U> PartialEq<&mut [U]> for UniqueEntityVec<T> {
impl<T: EntityEquivalent + PartialEq<U>, U> PartialEq<&mut [U]> for UniqueEntityEquivalentVec<T> {
fn eq(&self, other: &&mut [U]) -> bool {
self.0.eq(other)
}
}
impl<T: EntityEquivalent + PartialEq<U>, U: EntityEquivalent> PartialEq<&mut UniqueEntitySlice<U>>
for UniqueEntityVec<T>
impl<T: EntityEquivalent + PartialEq<U>, U: EntityEquivalent>
PartialEq<&mut UniqueEntityEquivalentSlice<U>> for UniqueEntityEquivalentVec<T>
{
fn eq(&self, other: &&mut UniqueEntitySlice<U>) -> bool {
fn eq(&self, other: &&mut UniqueEntityEquivalentSlice<U>) -> bool {
self.0.eq(other)
}
}
impl<T: EntityEquivalent + PartialEq<U>, U, const N: usize> PartialEq<&[U; N]>
for UniqueEntityVec<T>
for UniqueEntityEquivalentVec<T>
{
fn eq(&self, other: &&[U; N]) -> bool {
self.0.eq(other)
@ -555,15 +566,15 @@ impl<T: EntityEquivalent + PartialEq<U>, U, const N: usize> PartialEq<&[U; N]>
}
impl<T: EntityEquivalent + PartialEq<U>, U: EntityEquivalent, const N: usize>
PartialEq<&UniqueEntityArray<N, U>> for UniqueEntityVec<T>
PartialEq<&UniqueEntityEquivalentArray<U, N>> for UniqueEntityEquivalentVec<T>
{
fn eq(&self, other: &&UniqueEntityArray<N, U>) -> bool {
fn eq(&self, other: &&UniqueEntityEquivalentArray<U, N>) -> bool {
self.0.eq(&other.as_inner())
}
}
impl<T: EntityEquivalent + PartialEq<U>, U, const N: usize> PartialEq<&mut [U; N]>
for UniqueEntityVec<T>
for UniqueEntityEquivalentVec<T>
{
fn eq(&self, other: &&mut [U; N]) -> bool {
self.0.eq(&**other)
@ -571,29 +582,29 @@ impl<T: EntityEquivalent + PartialEq<U>, U, const N: usize> PartialEq<&mut [U; N
}
impl<T: EntityEquivalent + PartialEq<U>, U: EntityEquivalent, const N: usize>
PartialEq<&mut UniqueEntityArray<N, U>> for UniqueEntityVec<T>
PartialEq<&mut UniqueEntityEquivalentArray<U, N>> for UniqueEntityEquivalentVec<T>
{
fn eq(&self, other: &&mut UniqueEntityArray<N, U>) -> bool {
fn eq(&self, other: &&mut UniqueEntityEquivalentArray<U, N>) -> bool {
self.0.eq(other.as_inner())
}
}
impl<T: EntityEquivalent + PartialEq<U>, U> PartialEq<[U]> for UniqueEntityVec<T> {
impl<T: EntityEquivalent + PartialEq<U>, U> PartialEq<[U]> for UniqueEntityEquivalentVec<T> {
fn eq(&self, other: &[U]) -> bool {
self.0.eq(other)
}
}
impl<T: EntityEquivalent + PartialEq<U>, U: EntityEquivalent> PartialEq<UniqueEntitySlice<U>>
for UniqueEntityVec<T>
impl<T: EntityEquivalent + PartialEq<U>, U: EntityEquivalent>
PartialEq<UniqueEntityEquivalentSlice<U>> for UniqueEntityEquivalentVec<T>
{
fn eq(&self, other: &UniqueEntitySlice<U>) -> bool {
fn eq(&self, other: &UniqueEntityEquivalentSlice<U>) -> bool {
self.0.eq(&**other)
}
}
impl<T: EntityEquivalent + PartialEq<U>, U, const N: usize> PartialEq<[U; N]>
for UniqueEntityVec<T>
for UniqueEntityEquivalentVec<T>
{
fn eq(&self, other: &[U; N]) -> bool {
self.0.eq(other)
@ -601,247 +612,266 @@ impl<T: EntityEquivalent + PartialEq<U>, U, const N: usize> PartialEq<[U; N]>
}
impl<T: EntityEquivalent + PartialEq<U>, U: EntityEquivalent, const N: usize>
PartialEq<UniqueEntityArray<N, U>> for UniqueEntityVec<T>
PartialEq<UniqueEntityEquivalentArray<U, N>> for UniqueEntityEquivalentVec<T>
{
fn eq(&self, other: &UniqueEntityArray<N, U>) -> bool {
fn eq(&self, other: &UniqueEntityEquivalentArray<U, N>) -> bool {
self.0.eq(other.as_inner())
}
}
impl<T: PartialEq<U>, U: EntityEquivalent> PartialEq<UniqueEntityVec<U>> for Vec<T> {
fn eq(&self, other: &UniqueEntityVec<U>) -> bool {
impl<T: PartialEq<U>, U: EntityEquivalent> PartialEq<UniqueEntityEquivalentVec<U>> for Vec<T> {
fn eq(&self, other: &UniqueEntityEquivalentVec<U>) -> bool {
self.eq(&other.0)
}
}
impl<T: PartialEq<U>, U: EntityEquivalent> PartialEq<UniqueEntityVec<U>> for &[T] {
fn eq(&self, other: &UniqueEntityVec<U>) -> bool {
impl<T: PartialEq<U>, U: EntityEquivalent> PartialEq<UniqueEntityEquivalentVec<U>> for &[T] {
fn eq(&self, other: &UniqueEntityEquivalentVec<U>) -> bool {
self.eq(&other.0)
}
}
impl<T: PartialEq<U>, U: EntityEquivalent> PartialEq<UniqueEntityVec<U>> for &mut [T] {
fn eq(&self, other: &UniqueEntityVec<U>) -> bool {
impl<T: PartialEq<U>, U: EntityEquivalent> PartialEq<UniqueEntityEquivalentVec<U>> for &mut [T] {
fn eq(&self, other: &UniqueEntityEquivalentVec<U>) -> bool {
self.eq(&other.0)
}
}
impl<T: EntityEquivalent + PartialEq<U>, U: EntityEquivalent> PartialEq<UniqueEntityVec<U>>
for [T]
impl<T: EntityEquivalent + PartialEq<U>, U: EntityEquivalent>
PartialEq<UniqueEntityEquivalentVec<U>> for [T]
{
fn eq(&self, other: &UniqueEntityVec<U>) -> bool {
fn eq(&self, other: &UniqueEntityEquivalentVec<U>) -> bool {
self.eq(&other.0)
}
}
impl<T: PartialEq<U> + Clone, U: EntityEquivalent> PartialEq<UniqueEntityVec<U>> for Cow<'_, [T]> {
fn eq(&self, other: &UniqueEntityVec<U>) -> bool {
impl<T: PartialEq<U> + Clone, U: EntityEquivalent> PartialEq<UniqueEntityEquivalentVec<U>>
for Cow<'_, [T]>
{
fn eq(&self, other: &UniqueEntityEquivalentVec<U>) -> bool {
self.eq(&other.0)
}
}
impl<T: PartialEq<U>, U: EntityEquivalent> PartialEq<UniqueEntityVec<U>> for VecDeque<T> {
fn eq(&self, other: &UniqueEntityVec<U>) -> bool {
impl<T: PartialEq<U>, U: EntityEquivalent> PartialEq<UniqueEntityEquivalentVec<U>> for VecDeque<T> {
fn eq(&self, other: &UniqueEntityEquivalentVec<U>) -> bool {
self.eq(&other.0)
}
}
impl<T: EntityEquivalent + Clone> From<&UniqueEntitySlice<T>> for UniqueEntityVec<T> {
fn from(value: &UniqueEntitySlice<T>) -> Self {
impl<T: EntityEquivalent + Clone> From<&UniqueEntityEquivalentSlice<T>>
for UniqueEntityEquivalentVec<T>
{
fn from(value: &UniqueEntityEquivalentSlice<T>) -> Self {
value.to_vec()
}
}
impl<T: EntityEquivalent + Clone> From<&mut UniqueEntitySlice<T>> for UniqueEntityVec<T> {
fn from(value: &mut UniqueEntitySlice<T>) -> Self {
impl<T: EntityEquivalent + Clone> From<&mut UniqueEntityEquivalentSlice<T>>
for UniqueEntityEquivalentVec<T>
{
fn from(value: &mut UniqueEntityEquivalentSlice<T>) -> Self {
value.to_vec()
}
}
impl<T: EntityEquivalent> From<Box<UniqueEntitySlice<T>>> for UniqueEntityVec<T> {
fn from(value: Box<UniqueEntitySlice<T>>) -> Self {
impl<T: EntityEquivalent> From<Box<UniqueEntityEquivalentSlice<T>>>
for UniqueEntityEquivalentVec<T>
{
fn from(value: Box<UniqueEntityEquivalentSlice<T>>) -> Self {
value.into_vec()
}
}
impl<T: EntityEquivalent> From<Cow<'_, UniqueEntitySlice<T>>> for UniqueEntityVec<T>
impl<T: EntityEquivalent> From<Cow<'_, UniqueEntityEquivalentSlice<T>>>
for UniqueEntityEquivalentVec<T>
where
UniqueEntitySlice<T>: ToOwned<Owned = UniqueEntityVec<T>>,
UniqueEntityEquivalentSlice<T>: ToOwned<Owned = UniqueEntityEquivalentVec<T>>,
{
fn from(value: Cow<UniqueEntitySlice<T>>) -> Self {
fn from(value: Cow<UniqueEntityEquivalentSlice<T>>) -> Self {
value.into_owned()
}
}
impl<T: EntityEquivalent + Clone> From<&[T; 1]> for UniqueEntityVec<T> {
impl<T: EntityEquivalent + Clone> From<&[T; 1]> for UniqueEntityEquivalentVec<T> {
fn from(value: &[T; 1]) -> Self {
Self(Vec::from(value))
}
}
impl<T: EntityEquivalent + Clone> From<&[T; 0]> for UniqueEntityVec<T> {
impl<T: EntityEquivalent + Clone> From<&[T; 0]> for UniqueEntityEquivalentVec<T> {
fn from(value: &[T; 0]) -> Self {
Self(Vec::from(value))
}
}
impl<T: EntityEquivalent + Clone> From<&mut [T; 1]> for UniqueEntityVec<T> {
impl<T: EntityEquivalent + Clone> From<&mut [T; 1]> for UniqueEntityEquivalentVec<T> {
fn from(value: &mut [T; 1]) -> Self {
Self(Vec::from(value))
}
}
impl<T: EntityEquivalent + Clone> From<&mut [T; 0]> for UniqueEntityVec<T> {
impl<T: EntityEquivalent + Clone> From<&mut [T; 0]> for UniqueEntityEquivalentVec<T> {
fn from(value: &mut [T; 0]) -> Self {
Self(Vec::from(value))
}
}
impl<T: EntityEquivalent> From<[T; 1]> for UniqueEntityVec<T> {
impl<T: EntityEquivalent> From<[T; 1]> for UniqueEntityEquivalentVec<T> {
fn from(value: [T; 1]) -> Self {
Self(Vec::from(value))
}
}
impl<T: EntityEquivalent> From<[T; 0]> for UniqueEntityVec<T> {
impl<T: EntityEquivalent> From<[T; 0]> for UniqueEntityEquivalentVec<T> {
fn from(value: [T; 0]) -> Self {
Self(Vec::from(value))
}
}
impl<T: EntityEquivalent + Clone, const N: usize> From<&UniqueEntityArray<N, T>>
for UniqueEntityVec<T>
impl<T: EntityEquivalent + Clone, const N: usize> From<&UniqueEntityEquivalentArray<T, N>>
for UniqueEntityEquivalentVec<T>
{
fn from(value: &UniqueEntityArray<N, T>) -> Self {
fn from(value: &UniqueEntityEquivalentArray<T, N>) -> Self {
Self(Vec::from(value.as_inner().clone()))
}
}
impl<T: EntityEquivalent + Clone, const N: usize> From<&mut UniqueEntityArray<N, T>>
for UniqueEntityVec<T>
impl<T: EntityEquivalent + Clone, const N: usize> From<&mut UniqueEntityEquivalentArray<T, N>>
for UniqueEntityEquivalentVec<T>
{
fn from(value: &mut UniqueEntityArray<N, T>) -> Self {
fn from(value: &mut UniqueEntityEquivalentArray<T, N>) -> Self {
Self(Vec::from(value.as_inner().clone()))
}
}
impl<T: EntityEquivalent, const N: usize> From<UniqueEntityArray<N, T>> for UniqueEntityVec<T> {
fn from(value: UniqueEntityArray<N, T>) -> Self {
impl<T: EntityEquivalent, const N: usize> From<UniqueEntityEquivalentArray<T, N>>
for UniqueEntityEquivalentVec<T>
{
fn from(value: UniqueEntityEquivalentArray<T, N>) -> Self {
Self(Vec::from(value.into_inner()))
}
}
impl<T: EntityEquivalent> From<UniqueEntityVec<T>> for Vec<T> {
fn from(value: UniqueEntityVec<T>) -> Self {
impl<T: EntityEquivalent> From<UniqueEntityEquivalentVec<T>> for Vec<T> {
fn from(value: UniqueEntityEquivalentVec<T>) -> Self {
value.0
}
}
impl<'a, T: EntityEquivalent + Clone> From<UniqueEntityVec<T>> for Cow<'a, [T]> {
fn from(value: UniqueEntityVec<T>) -> Self {
impl<'a, T: EntityEquivalent + Clone> From<UniqueEntityEquivalentVec<T>> for Cow<'a, [T]> {
fn from(value: UniqueEntityEquivalentVec<T>) -> Self {
Cow::from(value.0)
}
}
impl<'a, T: EntityEquivalent + Clone> From<UniqueEntityVec<T>> for Cow<'a, UniqueEntitySlice<T>> {
fn from(value: UniqueEntityVec<T>) -> Self {
impl<'a, T: EntityEquivalent + Clone> From<UniqueEntityEquivalentVec<T>>
for Cow<'a, UniqueEntityEquivalentSlice<T>>
{
fn from(value: UniqueEntityEquivalentVec<T>) -> Self {
Cow::Owned(value)
}
}
impl<T: EntityEquivalent> From<UniqueEntityVec<T>> for Arc<[T]> {
fn from(value: UniqueEntityVec<T>) -> Self {
impl<T: EntityEquivalent> From<UniqueEntityEquivalentVec<T>> for Arc<[T]> {
fn from(value: UniqueEntityEquivalentVec<T>) -> Self {
Arc::from(value.0)
}
}
impl<T: EntityEquivalent> From<UniqueEntityVec<T>> for Arc<UniqueEntitySlice<T>> {
fn from(value: UniqueEntityVec<T>) -> Self {
impl<T: EntityEquivalent> From<UniqueEntityEquivalentVec<T>>
for Arc<UniqueEntityEquivalentSlice<T>>
{
fn from(value: UniqueEntityEquivalentVec<T>) -> Self {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_arc_slice_unchecked(Arc::from(value.0)) }
unsafe { UniqueEntityEquivalentSlice::from_arc_slice_unchecked(Arc::from(value.0)) }
}
}
impl<T: EntityEquivalent + Ord> From<UniqueEntityVec<T>> for BinaryHeap<T> {
fn from(value: UniqueEntityVec<T>) -> Self {
impl<T: EntityEquivalent + Ord> From<UniqueEntityEquivalentVec<T>> for BinaryHeap<T> {
fn from(value: UniqueEntityEquivalentVec<T>) -> Self {
BinaryHeap::from(value.0)
}
}
impl<T: EntityEquivalent> From<UniqueEntityVec<T>> for Box<[T]> {
fn from(value: UniqueEntityVec<T>) -> Self {
impl<T: EntityEquivalent> From<UniqueEntityEquivalentVec<T>> for Box<[T]> {
fn from(value: UniqueEntityEquivalentVec<T>) -> Self {
Box::from(value.0)
}
}
impl<T: EntityEquivalent> From<UniqueEntityVec<T>> for Rc<[T]> {
fn from(value: UniqueEntityVec<T>) -> Self {
impl<T: EntityEquivalent> From<UniqueEntityEquivalentVec<T>> for Rc<[T]> {
fn from(value: UniqueEntityEquivalentVec<T>) -> Self {
Rc::from(value.0)
}
}
impl<T: EntityEquivalent> From<UniqueEntityVec<T>> for Rc<UniqueEntitySlice<T>> {
fn from(value: UniqueEntityVec<T>) -> Self {
impl<T: EntityEquivalent> From<UniqueEntityEquivalentVec<T>>
for Rc<UniqueEntityEquivalentSlice<T>>
{
fn from(value: UniqueEntityEquivalentVec<T>) -> Self {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_rc_slice_unchecked(Rc::from(value.0)) }
unsafe { UniqueEntityEquivalentSlice::from_rc_slice_unchecked(Rc::from(value.0)) }
}
}
impl<T: EntityEquivalent> From<UniqueEntityVec<T>> for VecDeque<T> {
fn from(value: UniqueEntityVec<T>) -> Self {
impl<T: EntityEquivalent> From<UniqueEntityEquivalentVec<T>> for VecDeque<T> {
fn from(value: UniqueEntityEquivalentVec<T>) -> Self {
VecDeque::from(value.0)
}
}
impl<T: EntityEquivalent, const N: usize> TryFrom<UniqueEntityVec<T>> for Box<[T; N]> {
type Error = UniqueEntityVec<T>;
impl<T: EntityEquivalent, const N: usize> TryFrom<UniqueEntityEquivalentVec<T>> for Box<[T; N]> {
type Error = UniqueEntityEquivalentVec<T>;
fn try_from(value: UniqueEntityVec<T>) -> Result<Self, Self::Error> {
Box::try_from(value.0).map_err(UniqueEntityVec)
fn try_from(value: UniqueEntityEquivalentVec<T>) -> Result<Self, Self::Error> {
Box::try_from(value.0).map_err(UniqueEntityEquivalentVec)
}
}
impl<T: EntityEquivalent, const N: usize> TryFrom<UniqueEntityVec<T>>
for Box<UniqueEntityArray<N, T>>
impl<T: EntityEquivalent, const N: usize> TryFrom<UniqueEntityEquivalentVec<T>>
for Box<UniqueEntityEquivalentArray<T, N>>
{
type Error = UniqueEntityVec<T>;
type Error = UniqueEntityEquivalentVec<T>;
fn try_from(value: UniqueEntityVec<T>) -> Result<Self, Self::Error> {
fn try_from(value: UniqueEntityEquivalentVec<T>) -> Result<Self, Self::Error> {
Box::try_from(value.0)
.map(|v|
// SAFETY: All elements in the original Vec are unique.
unsafe { UniqueEntityArray::from_boxed_array_unchecked(v) })
.map_err(UniqueEntityVec)
unsafe { UniqueEntityEquivalentArray::from_boxed_array_unchecked(v) })
.map_err(UniqueEntityEquivalentVec)
}
}
impl<T: EntityEquivalent, const N: usize> TryFrom<UniqueEntityVec<T>> for [T; N] {
type Error = UniqueEntityVec<T>;
impl<T: EntityEquivalent, const N: usize> TryFrom<UniqueEntityEquivalentVec<T>> for [T; N] {
type Error = UniqueEntityEquivalentVec<T>;
fn try_from(value: UniqueEntityVec<T>) -> Result<Self, Self::Error> {
<[T; N] as TryFrom<Vec<T>>>::try_from(value.0).map_err(UniqueEntityVec)
fn try_from(value: UniqueEntityEquivalentVec<T>) -> Result<Self, Self::Error> {
<[T; N] as TryFrom<Vec<T>>>::try_from(value.0).map_err(UniqueEntityEquivalentVec)
}
}
impl<T: EntityEquivalent, const N: usize> TryFrom<UniqueEntityVec<T>> for UniqueEntityArray<N, T> {
type Error = UniqueEntityVec<T>;
impl<T: EntityEquivalent, const N: usize> TryFrom<UniqueEntityEquivalentVec<T>>
for UniqueEntityEquivalentArray<T, N>
{
type Error = UniqueEntityEquivalentVec<T>;
fn try_from(value: UniqueEntityVec<T>) -> Result<Self, Self::Error> {
fn try_from(value: UniqueEntityEquivalentVec<T>) -> Result<Self, Self::Error> {
<[T; N] as TryFrom<Vec<T>>>::try_from(value.0)
.map(|v|
// SAFETY: All elements in the original Vec are unique.
unsafe { UniqueEntityArray::from_array_unchecked(v) })
.map_err(UniqueEntityVec)
unsafe { UniqueEntityEquivalentArray::from_array_unchecked(v) })
.map_err(UniqueEntityEquivalentVec)
}
}
impl<T: EntityEquivalent> From<BTreeSet<T>> for UniqueEntityVec<T> {
impl<T: EntityEquivalent> From<BTreeSet<T>> for UniqueEntityEquivalentVec<T> {
fn from(value: BTreeSet<T>) -> Self {
Self(value.into_iter().collect::<Vec<T>>())
}
}
impl<T: EntityEquivalent> FromIterator<T> for UniqueEntityVec<T> {
impl<T: EntityEquivalent> FromIterator<T> for UniqueEntityEquivalentVec<T> {
/// This impl only uses `Eq` to validate uniqueness, resulting in O(n^2) complexity.
/// It can make sense for very low N, or if `T` implements neither `Ord` nor `Hash`.
/// When possible, use `FromEntitySetIterator::from_entity_iter` instead.
@ -860,14 +890,14 @@ impl<T: EntityEquivalent> FromIterator<T> for UniqueEntityVec<T> {
}
}
impl<T: EntityEquivalent> FromEntitySetIterator<T> for UniqueEntityVec<T> {
impl<T: EntityEquivalent> FromEntitySetIterator<T> for UniqueEntityEquivalentVec<T> {
fn from_entity_set_iter<I: EntitySet<Item = T>>(iter: I) -> Self {
// SAFETY: `iter` is an `EntitySet`.
unsafe { Self::from_vec_unchecked(Vec::from_iter(iter)) }
}
}
impl<T: EntityEquivalent> Extend<T> for UniqueEntityVec<T> {
impl<T: EntityEquivalent> Extend<T> for UniqueEntityEquivalentVec<T> {
/// Use with caution, because this impl only uses `Eq` to validate uniqueness,
/// resulting in O(n^2) complexity.
/// It can make sense for very low N, or if `T` implements neither `Ord` nor `Hash`.
@ -894,7 +924,7 @@ impl<T: EntityEquivalent> Extend<T> for UniqueEntityVec<T> {
}
}
impl<'a, T: EntityEquivalent + Copy + 'a> Extend<&'a T> for UniqueEntityVec<T> {
impl<'a, T: EntityEquivalent + Copy + 'a> Extend<&'a T> for UniqueEntityEquivalentVec<T> {
/// Use with caution, because this impl only uses `Eq` to validate uniqueness,
/// resulting in O(n^2) complexity.
/// It can make sense for very low N, or if `T` implements neither `Ord` nor `Hash`.
@ -921,145 +951,149 @@ impl<'a, T: EntityEquivalent + Copy + 'a> Extend<&'a T> for UniqueEntityVec<T> {
}
}
impl<T: EntityEquivalent> Index<(Bound<usize>, Bound<usize>)> for UniqueEntityVec<T> {
type Output = UniqueEntitySlice<T>;
impl<T: EntityEquivalent> Index<(Bound<usize>, Bound<usize>)> for UniqueEntityEquivalentVec<T> {
type Output = UniqueEntityEquivalentSlice<T>;
fn index(&self, key: (Bound<usize>, Bound<usize>)) -> &Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked(self.0.index(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked(self.0.index(key)) }
}
}
impl<T: EntityEquivalent> Index<Range<usize>> for UniqueEntityVec<T> {
type Output = UniqueEntitySlice<T>;
impl<T: EntityEquivalent> Index<Range<usize>> for UniqueEntityEquivalentVec<T> {
type Output = UniqueEntityEquivalentSlice<T>;
fn index(&self, key: Range<usize>) -> &Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked(self.0.index(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked(self.0.index(key)) }
}
}
impl<T: EntityEquivalent> Index<RangeFrom<usize>> for UniqueEntityVec<T> {
type Output = UniqueEntitySlice<T>;
impl<T: EntityEquivalent> Index<RangeFrom<usize>> for UniqueEntityEquivalentVec<T> {
type Output = UniqueEntityEquivalentSlice<T>;
fn index(&self, key: RangeFrom<usize>) -> &Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked(self.0.index(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked(self.0.index(key)) }
}
}
impl<T: EntityEquivalent> Index<RangeFull> for UniqueEntityVec<T> {
type Output = UniqueEntitySlice<T>;
impl<T: EntityEquivalent> Index<RangeFull> for UniqueEntityEquivalentVec<T> {
type Output = UniqueEntityEquivalentSlice<T>;
fn index(&self, key: RangeFull) -> &Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked(self.0.index(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked(self.0.index(key)) }
}
}
impl<T: EntityEquivalent> Index<RangeInclusive<usize>> for UniqueEntityVec<T> {
type Output = UniqueEntitySlice<T>;
impl<T: EntityEquivalent> Index<RangeInclusive<usize>> for UniqueEntityEquivalentVec<T> {
type Output = UniqueEntityEquivalentSlice<T>;
fn index(&self, key: RangeInclusive<usize>) -> &Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked(self.0.index(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked(self.0.index(key)) }
}
}
impl<T: EntityEquivalent> Index<RangeTo<usize>> for UniqueEntityVec<T> {
type Output = UniqueEntitySlice<T>;
impl<T: EntityEquivalent> Index<RangeTo<usize>> for UniqueEntityEquivalentVec<T> {
type Output = UniqueEntityEquivalentSlice<T>;
fn index(&self, key: RangeTo<usize>) -> &Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked(self.0.index(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked(self.0.index(key)) }
}
}
impl<T: EntityEquivalent> Index<RangeToInclusive<usize>> for UniqueEntityVec<T> {
type Output = UniqueEntitySlice<T>;
impl<T: EntityEquivalent> Index<RangeToInclusive<usize>> for UniqueEntityEquivalentVec<T> {
type Output = UniqueEntityEquivalentSlice<T>;
fn index(&self, key: RangeToInclusive<usize>) -> &Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked(self.0.index(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked(self.0.index(key)) }
}
}
impl<T: EntityEquivalent> Index<usize> for UniqueEntityVec<T> {
impl<T: EntityEquivalent> Index<usize> for UniqueEntityEquivalentVec<T> {
type Output = T;
fn index(&self, key: usize) -> &T {
self.0.index(key)
}
}
impl<T: EntityEquivalent> IndexMut<(Bound<usize>, Bound<usize>)> for UniqueEntityVec<T> {
impl<T: EntityEquivalent> IndexMut<(Bound<usize>, Bound<usize>)> for UniqueEntityEquivalentVec<T> {
fn index_mut(&mut self, key: (Bound<usize>, Bound<usize>)) -> &mut Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
}
}
impl<T: EntityEquivalent> IndexMut<Range<usize>> for UniqueEntityVec<T> {
impl<T: EntityEquivalent> IndexMut<Range<usize>> for UniqueEntityEquivalentVec<T> {
fn index_mut(&mut self, key: Range<usize>) -> &mut Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
}
}
impl<T: EntityEquivalent> IndexMut<RangeFrom<usize>> for UniqueEntityVec<T> {
impl<T: EntityEquivalent> IndexMut<RangeFrom<usize>> for UniqueEntityEquivalentVec<T> {
fn index_mut(&mut self, key: RangeFrom<usize>) -> &mut Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
}
}
impl<T: EntityEquivalent> IndexMut<RangeFull> for UniqueEntityVec<T> {
impl<T: EntityEquivalent> IndexMut<RangeFull> for UniqueEntityEquivalentVec<T> {
fn index_mut(&mut self, key: RangeFull) -> &mut Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
}
}
impl<T: EntityEquivalent> IndexMut<RangeInclusive<usize>> for UniqueEntityVec<T> {
impl<T: EntityEquivalent> IndexMut<RangeInclusive<usize>> for UniqueEntityEquivalentVec<T> {
fn index_mut(&mut self, key: RangeInclusive<usize>) -> &mut Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
}
}
impl<T: EntityEquivalent> IndexMut<RangeTo<usize>> for UniqueEntityVec<T> {
impl<T: EntityEquivalent> IndexMut<RangeTo<usize>> for UniqueEntityEquivalentVec<T> {
fn index_mut(&mut self, key: RangeTo<usize>) -> &mut Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
}
}
impl<T: EntityEquivalent> IndexMut<RangeToInclusive<usize>> for UniqueEntityVec<T> {
impl<T: EntityEquivalent> IndexMut<RangeToInclusive<usize>> for UniqueEntityEquivalentVec<T> {
fn index_mut(&mut self, key: RangeToInclusive<usize>) -> &mut Self::Output {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked_mut(self.0.index_mut(key)) }
}
}
/// An iterator that moves out of a vector.
///
/// This `struct` is created by the [`IntoIterator::into_iter`] trait
/// method on [`UniqueEntityVec`].
/// method on [`UniqueEntityEquivalentVec`].
pub type IntoIter<T = Entity> = UniqueEntityIter<vec::IntoIter<T>>;
impl<T: EntityEquivalent> UniqueEntityIter<vec::IntoIter<T>> {
/// Returns the remaining items of this iterator as a slice.
///
/// Equivalent to [`vec::IntoIter::as_slice`].
pub fn as_slice(&self) -> &UniqueEntitySlice<T> {
pub fn as_slice(&self) -> &UniqueEntityEquivalentSlice<T> {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked(self.as_inner().as_slice()) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked(self.as_inner().as_slice()) }
}
/// Returns the remaining items of this iterator as a mutable slice.
///
/// Equivalent to [`vec::IntoIter::as_mut_slice`].
pub fn as_mut_slice(&mut self) -> &mut UniqueEntitySlice<T> {
pub fn as_mut_slice(&mut self) -> &mut UniqueEntityEquivalentSlice<T> {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked_mut(self.as_mut_inner().as_mut_slice()) }
unsafe {
UniqueEntityEquivalentSlice::from_slice_unchecked_mut(
self.as_mut_inner().as_mut_slice(),
)
}
}
}
/// A draining iterator for [`UniqueEntityVec<T>`].
/// A draining iterator for [`UniqueEntityEquivalentVec<T>`].
///
/// This struct is created by [`UniqueEntityVec::drain`].
/// This struct is created by [`UniqueEntityEquivalentVec::drain`].
/// See its documentation for more.
pub type Drain<'a, T = Entity> = UniqueEntityIter<vec::Drain<'a, T>>;
@ -1067,14 +1101,14 @@ impl<'a, T: EntityEquivalent> UniqueEntityIter<vec::Drain<'a, T>> {
/// Returns the remaining items of this iterator as a slice.
///
/// Equivalent to [`vec::Drain::as_slice`].
pub fn as_slice(&self) -> &UniqueEntitySlice<T> {
pub fn as_slice(&self) -> &UniqueEntityEquivalentSlice<T> {
// SAFETY: All elements in the original slice are unique.
unsafe { UniqueEntitySlice::from_slice_unchecked(self.as_inner().as_slice()) }
unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked(self.as_inner().as_slice()) }
}
}
/// A splicing iterator for [`UniqueEntityVec`].
/// A splicing iterator for [`UniqueEntityEquivalentVec`].
///
/// This struct is created by [`UniqueEntityVec::splice`].
/// This struct is created by [`UniqueEntityEquivalentVec::splice`].
/// See its documentation for more.
pub type Splice<'a, I> = UniqueEntityIter<vec::Splice<'a, I>>;

6
crates/bevy_ecs/src/query/par_iter.rs
View File

@ -1,7 +1,7 @@
use crate::{
batching::BatchingStrategy,
component::Tick,
entity::{EntityEquivalent, UniqueEntityVec},
entity::{EntityEquivalent, UniqueEntityEquivalentVec},
world::unsafe_world_cell::UnsafeWorldCell,
};
@ -318,7 +318,7 @@ pub struct QueryParManyUniqueIter<'w, 's, D: QueryData, F: QueryFilter, E: Entit
{
pub(crate) world: UnsafeWorldCell<'w>,
pub(crate) state: &'s QueryState<D, F>,
pub(crate) entity_list: UniqueEntityVec<E>,
pub(crate) entity_list: UniqueEntityEquivalentVec<E>,
pub(crate) last_run: Tick,
pub(crate) this_run: Tick,
pub(crate) batching_strategy: BatchingStrategy,
@ -369,7 +369,7 @@ impl<'w, 's, D: QueryData, F: QueryFilter, E: EntityEquivalent + Sync>
/// struct T;
///
/// #[derive(Resource)]
/// struct V(UniqueEntityVec<Entity>);
/// struct V(UniqueEntityVec);
///
/// impl<'a> IntoIterator for &'a V {
/// // ...

4
crates/bevy_ecs/src/query/state.rs
View File

@ -11,7 +11,7 @@ use crate::{
};
#[cfg(all(not(target_arch = "wasm32"), feature = "multi_threaded"))]
use crate::entity::UniqueEntitySlice;
use crate::entity::UniqueEntityEquivalentSlice;
use alloc::vec::Vec;
use core::{fmt, ptr};
@ -1606,7 +1606,7 @@ impl<D: QueryData, F: QueryFilter> QueryState<D, F> {
&self,
init_accum: INIT,
world: UnsafeWorldCell<'w>,
entity_list: &UniqueEntitySlice<E>,
entity_list: &UniqueEntityEquivalentSlice<E>,
batch_size: usize,
mut func: FN,
last_run: Tick,

2
crates/bevy_ecs/src/system/query.rs
View File

@ -1733,7 +1733,7 @@ impl<'w, 's, D: QueryData, F: QueryFilter> Query<'w, 's, D, F> {
///
/// let mut world = World::new();
///
/// let entity_set: UniqueEntityVec<_> = world.spawn_batch((0..3).map(A)).collect_set();
/// let entity_set: UniqueEntityVec = world.spawn_batch((0..3).map(A)).collect_set();
/// let entity_set: UniqueEntityArray<3> = entity_set.try_into().unwrap();
///
/// world.spawn(A(73));