add Entity default to the entity set wrappers (#18319)
# Objective Installment of the #16547 series. The vast majority of uses for these types will be the `Entity` case, so it makes sense for it to be the default. ## Solution `UniqueEntityVec`, `UniqueEntitySlice`, `UniqueEntityArray` and their helper iterator aliases now have `Entity` as a default. Unfortunately, this means the the `T` parameter for `UniqueEntityArray` now has to be ordered after the `N` constant, which breaks the consistency to `[T; N]`. Same with about a dozen iterator aliases that take some `P`/`F` predicate/function parameter. This should however be an ergonomic improvement in most cases, so we'll just have to live with this inconsistency. ## Migration Guide Switch type parameter order for the relevant wrapper types/aliases.
This commit is contained in:
Vic
GitHub
parent
cb3e6a88dc
commit
b462f47864
@ -22,7 +22,7 @@ use bevy_platform_support::sync::Arc;
|
||||
|
||||
use super::{
|
||||
unique_slice::{self, UniqueEntitySlice},
|
||||
TrustedEntityBorrow, UniqueEntityIter,
|
||||
Entity, TrustedEntityBorrow, UniqueEntityIter,
|
||||
};
|
||||
|
||||
/// An array that contains only unique entities.
|
||||
@ -30,9 +30,9 @@ use super::{
|
||||
/// It can be obtained through certain methods on [`UniqueEntitySlice`],
|
||||
/// and some [`TryFrom`] implementations.
|
||||
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
|
||||
pub struct UniqueEntityArray<T: TrustedEntityBorrow, const N: usize>([T; N]);
|
||||
pub struct UniqueEntityArray<const N: usize, T: TrustedEntityBorrow = Entity>([T; N]);
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> UniqueEntityArray<T, N> {
|
||||
impl<T: TrustedEntityBorrow, const N: usize> UniqueEntityArray<N, T> {
|
||||
/// Constructs a `UniqueEntityArray` from a [`[T; N]`] unsafely.
|
||||
///
|
||||
/// # Safety
|
||||
@ -127,12 +127,12 @@ impl<T: TrustedEntityBorrow, const N: usize> UniqueEntityArray<T, N> {
|
||||
/// size as `self`.
|
||||
///
|
||||
/// Equivalent to [`[T; N]::as_ref`](array::each_ref).
|
||||
pub fn each_ref(&self) -> UniqueEntityArray<&T, N> {
|
||||
pub fn each_ref(&self) -> UniqueEntityArray<N, &T> {
|
||||
UniqueEntityArray(self.0.each_ref())
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> Deref for UniqueEntityArray<T, N> {
|
||||
impl<T: TrustedEntityBorrow, const N: usize> Deref for UniqueEntityArray<N, T> {
|
||||
type Target = UniqueEntitySlice<T>;
|
||||
|
||||
fn deref(&self) -> &Self::Target {
|
||||
@ -141,19 +141,19 @@ impl<T: TrustedEntityBorrow, const N: usize> Deref for UniqueEntityArray<T, N> {
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> DerefMut for UniqueEntityArray<T, N> {
|
||||
impl<T: TrustedEntityBorrow, const N: usize> DerefMut for UniqueEntityArray<N, T> {
|
||||
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) }
|
||||
}
|
||||
}
|
||||
impl<T: TrustedEntityBorrow> Default for UniqueEntityArray<T, 0> {
|
||||
impl<T: TrustedEntityBorrow> Default for UniqueEntityArray<0, T> {
|
||||
fn default() -> Self {
|
||||
Self(Default::default())
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, T: TrustedEntityBorrow, const N: usize> IntoIterator for &'a UniqueEntityArray<T, N> {
|
||||
impl<'a, T: TrustedEntityBorrow, const N: usize> IntoIterator for &'a UniqueEntityArray<N, T> {
|
||||
type Item = &'a T;
|
||||
|
||||
type IntoIter = unique_slice::Iter<'a, T>;
|
||||
@ -164,10 +164,10 @@ impl<'a, T: TrustedEntityBorrow, const N: usize> IntoIterator for &'a UniqueEnti
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> IntoIterator for UniqueEntityArray<T, N> {
|
||||
impl<T: TrustedEntityBorrow, const N: usize> IntoIterator for UniqueEntityArray<N, T> {
|
||||
type Item = T;
|
||||
|
||||
type IntoIter = IntoIter<T, N>;
|
||||
type IntoIter = IntoIter<N, T>;
|
||||
|
||||
fn into_iter(self) -> Self::IntoIter {
|
||||
// SAFETY: All elements in the original array are unique.
|
||||
@ -176,7 +176,7 @@ impl<T: TrustedEntityBorrow, const N: usize> IntoIterator for UniqueEntityArray<
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> AsRef<UniqueEntitySlice<T>>
|
||||
for UniqueEntityArray<T, N>
|
||||
for UniqueEntityArray<N, T>
|
||||
{
|
||||
fn as_ref(&self) -> &UniqueEntitySlice<T> {
|
||||
self
|
||||
@ -184,7 +184,7 @@ impl<T: TrustedEntityBorrow, const N: usize> AsRef<UniqueEntitySlice<T>>
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> AsMut<UniqueEntitySlice<T>>
|
||||
for UniqueEntityArray<T, N>
|
||||
for UniqueEntityArray<N, T>
|
||||
{
|
||||
fn as_mut(&mut self) -> &mut UniqueEntitySlice<T> {
|
||||
self
|
||||
@ -192,7 +192,7 @@ impl<T: TrustedEntityBorrow, const N: usize> AsMut<UniqueEntitySlice<T>>
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> Borrow<UniqueEntitySlice<T>>
|
||||
for UniqueEntityArray<T, N>
|
||||
for UniqueEntityArray<N, T>
|
||||
{
|
||||
fn borrow(&self) -> &UniqueEntitySlice<T> {
|
||||
self
|
||||
@ -200,7 +200,7 @@ impl<T: TrustedEntityBorrow, const N: usize> Borrow<UniqueEntitySlice<T>>
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> BorrowMut<UniqueEntitySlice<T>>
|
||||
for UniqueEntityArray<T, N>
|
||||
for UniqueEntityArray<N, T>
|
||||
{
|
||||
fn borrow_mut(&mut self) -> &mut UniqueEntitySlice<T> {
|
||||
self
|
||||
@ -208,7 +208,7 @@ impl<T: TrustedEntityBorrow, const N: usize> BorrowMut<UniqueEntitySlice<T>>
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> Index<(Bound<usize>, Bound<usize>)>
|
||||
for UniqueEntityArray<T, N>
|
||||
for UniqueEntityArray<N, T>
|
||||
{
|
||||
type Output = UniqueEntitySlice<T>;
|
||||
fn index(&self, key: (Bound<usize>, Bound<usize>)) -> &Self::Output {
|
||||
@ -217,7 +217,7 @@ impl<T: TrustedEntityBorrow, const N: usize> Index<(Bound<usize>, Bound<usize>)>
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> Index<Range<usize>> for UniqueEntityArray<T, N> {
|
||||
impl<T: TrustedEntityBorrow, const N: usize> Index<Range<usize>> for UniqueEntityArray<N, T> {
|
||||
type Output = UniqueEntitySlice<T>;
|
||||
fn index(&self, key: Range<usize>) -> &Self::Output {
|
||||
// SAFETY: All elements in the original slice are unique.
|
||||
@ -225,7 +225,7 @@ impl<T: TrustedEntityBorrow, const N: usize> Index<Range<usize>> for UniqueEntit
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> Index<RangeFrom<usize>> for UniqueEntityArray<T, N> {
|
||||
impl<T: TrustedEntityBorrow, const N: usize> Index<RangeFrom<usize>> for UniqueEntityArray<N, T> {
|
||||
type Output = UniqueEntitySlice<T>;
|
||||
fn index(&self, key: RangeFrom<usize>) -> &Self::Output {
|
||||
// SAFETY: All elements in the original slice are unique.
|
||||
@ -233,7 +233,7 @@ impl<T: TrustedEntityBorrow, const N: usize> Index<RangeFrom<usize>> for UniqueE
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> Index<RangeFull> for UniqueEntityArray<T, N> {
|
||||
impl<T: TrustedEntityBorrow, const N: usize> Index<RangeFull> for UniqueEntityArray<N, T> {
|
||||
type Output = UniqueEntitySlice<T>;
|
||||
fn index(&self, key: RangeFull) -> &Self::Output {
|
||||
// SAFETY: All elements in the original slice are unique.
|
||||
@ -242,7 +242,7 @@ impl<T: TrustedEntityBorrow, const N: usize> Index<RangeFull> for UniqueEntityAr
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> Index<RangeInclusive<usize>>
|
||||
for UniqueEntityArray<T, N>
|
||||
for UniqueEntityArray<N, T>
|
||||
{
|
||||
type Output = UniqueEntitySlice<T>;
|
||||
fn index(&self, key: RangeInclusive<usize>) -> &Self::Output {
|
||||
@ -251,7 +251,7 @@ impl<T: TrustedEntityBorrow, const N: usize> Index<RangeInclusive<usize>>
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> Index<RangeTo<usize>> for UniqueEntityArray<T, N> {
|
||||
impl<T: TrustedEntityBorrow, const N: usize> Index<RangeTo<usize>> for UniqueEntityArray<N, T> {
|
||||
type Output = UniqueEntitySlice<T>;
|
||||
fn index(&self, key: RangeTo<usize>) -> &Self::Output {
|
||||
// SAFETY: All elements in the original slice are unique.
|
||||
@ -260,7 +260,7 @@ impl<T: TrustedEntityBorrow, const N: usize> Index<RangeTo<usize>> for UniqueEnt
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> Index<RangeToInclusive<usize>>
|
||||
for UniqueEntityArray<T, N>
|
||||
for UniqueEntityArray<N, T>
|
||||
{
|
||||
type Output = UniqueEntitySlice<T>;
|
||||
fn index(&self, key: RangeToInclusive<usize>) -> &Self::Output {
|
||||
@ -269,7 +269,7 @@ impl<T: TrustedEntityBorrow, const N: usize> Index<RangeToInclusive<usize>>
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> Index<usize> for UniqueEntityArray<T, N> {
|
||||
impl<T: TrustedEntityBorrow, const N: usize> Index<usize> for UniqueEntityArray<N, T> {
|
||||
type Output = T;
|
||||
fn index(&self, key: usize) -> &T {
|
||||
self.0.index(key)
|
||||
@ -277,7 +277,7 @@ impl<T: TrustedEntityBorrow, const N: usize> Index<usize> for UniqueEntityArray<
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> IndexMut<(Bound<usize>, Bound<usize>)>
|
||||
for UniqueEntityArray<T, N>
|
||||
for UniqueEntityArray<N, T>
|
||||
{
|
||||
fn index_mut(&mut self, key: (Bound<usize>, Bound<usize>)) -> &mut Self::Output {
|
||||
// SAFETY: All elements in the original slice are unique.
|
||||
@ -285,7 +285,7 @@ impl<T: TrustedEntityBorrow, const N: usize> IndexMut<(Bound<usize>, Bound<usize
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> IndexMut<Range<usize>> for UniqueEntityArray<T, N> {
|
||||
impl<T: TrustedEntityBorrow, const N: usize> IndexMut<Range<usize>> for UniqueEntityArray<N, 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)) }
|
||||
@ -293,7 +293,7 @@ impl<T: TrustedEntityBorrow, const N: usize> IndexMut<Range<usize>> for UniqueEn
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> IndexMut<RangeFrom<usize>>
|
||||
for UniqueEntityArray<T, N>
|
||||
for UniqueEntityArray<N, T>
|
||||
{
|
||||
fn index_mut(&mut self, key: RangeFrom<usize>) -> &mut Self::Output {
|
||||
// SAFETY: All elements in the original slice are unique.
|
||||
@ -301,7 +301,7 @@ impl<T: TrustedEntityBorrow, const N: usize> IndexMut<RangeFrom<usize>>
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> IndexMut<RangeFull> for UniqueEntityArray<T, N> {
|
||||
impl<T: TrustedEntityBorrow, const N: usize> IndexMut<RangeFull> for UniqueEntityArray<N, 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)) }
|
||||
@ -309,7 +309,7 @@ impl<T: TrustedEntityBorrow, const N: usize> IndexMut<RangeFull> for UniqueEntit
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> IndexMut<RangeInclusive<usize>>
|
||||
for UniqueEntityArray<T, N>
|
||||
for UniqueEntityArray<N, T>
|
||||
{
|
||||
fn index_mut(&mut self, key: RangeInclusive<usize>) -> &mut Self::Output {
|
||||
// SAFETY: All elements in the original slice are unique.
|
||||
@ -317,7 +317,7 @@ impl<T: TrustedEntityBorrow, const N: usize> IndexMut<RangeInclusive<usize>>
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> IndexMut<RangeTo<usize>> for UniqueEntityArray<T, N> {
|
||||
impl<T: TrustedEntityBorrow, const N: usize> IndexMut<RangeTo<usize>> for UniqueEntityArray<N, 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)) }
|
||||
@ -325,7 +325,7 @@ impl<T: TrustedEntityBorrow, const N: usize> IndexMut<RangeTo<usize>> for Unique
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> IndexMut<RangeToInclusive<usize>>
|
||||
for UniqueEntityArray<T, N>
|
||||
for UniqueEntityArray<N, T>
|
||||
{
|
||||
fn index_mut(&mut self, key: RangeToInclusive<usize>) -> &mut Self::Output {
|
||||
// SAFETY: All elements in the original slice are unique.
|
||||
@ -333,148 +333,148 @@ impl<T: TrustedEntityBorrow, const N: usize> IndexMut<RangeToInclusive<usize>>
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow + Clone> From<&[T; 1]> for UniqueEntityArray<T, 1> {
|
||||
impl<T: TrustedEntityBorrow + Clone> From<&[T; 1]> for UniqueEntityArray<1, T> {
|
||||
fn from(value: &[T; 1]) -> Self {
|
||||
Self(value.clone())
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow + Clone> From<&[T; 0]> for UniqueEntityArray<T, 0> {
|
||||
impl<T: TrustedEntityBorrow + Clone> From<&[T; 0]> for UniqueEntityArray<0, T> {
|
||||
fn from(value: &[T; 0]) -> Self {
|
||||
Self(value.clone())
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow + Clone> From<&mut [T; 1]> for UniqueEntityArray<T, 1> {
|
||||
impl<T: TrustedEntityBorrow + Clone> From<&mut [T; 1]> for UniqueEntityArray<1, T> {
|
||||
fn from(value: &mut [T; 1]) -> Self {
|
||||
Self(value.clone())
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow + Clone> From<&mut [T; 0]> for UniqueEntityArray<T, 0> {
|
||||
impl<T: TrustedEntityBorrow + Clone> From<&mut [T; 0]> for UniqueEntityArray<0, T> {
|
||||
fn from(value: &mut [T; 0]) -> Self {
|
||||
Self(value.clone())
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow> From<[T; 1]> for UniqueEntityArray<T, 1> {
|
||||
impl<T: TrustedEntityBorrow> From<[T; 1]> for UniqueEntityArray<1, T> {
|
||||
fn from(value: [T; 1]) -> Self {
|
||||
Self(value)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow> From<[T; 0]> for UniqueEntityArray<T, 0> {
|
||||
impl<T: TrustedEntityBorrow> From<[T; 0]> for UniqueEntityArray<0, T> {
|
||||
fn from(value: [T; 0]) -> Self {
|
||||
Self(value)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow> From<UniqueEntityArray<T, 1>> for (T,) {
|
||||
fn from(array: UniqueEntityArray<T, 1>) -> Self {
|
||||
impl<T: TrustedEntityBorrow> From<UniqueEntityArray<1, T>> for (T,) {
|
||||
fn from(array: UniqueEntityArray<1, T>) -> Self {
|
||||
Self::from(array.into_inner())
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow> From<UniqueEntityArray<T, 2>> for (T, T) {
|
||||
fn from(array: UniqueEntityArray<T, 2>) -> Self {
|
||||
impl<T: TrustedEntityBorrow> From<UniqueEntityArray<2, T>> for (T, T) {
|
||||
fn from(array: UniqueEntityArray<2, T>) -> Self {
|
||||
Self::from(array.into_inner())
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow> From<UniqueEntityArray<T, 3>> for (T, T, T) {
|
||||
fn from(array: UniqueEntityArray<T, 3>) -> Self {
|
||||
impl<T: TrustedEntityBorrow> From<UniqueEntityArray<3, T>> for (T, T, T) {
|
||||
fn from(array: UniqueEntityArray<3, T>) -> Self {
|
||||
Self::from(array.into_inner())
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow> From<UniqueEntityArray<T, 4>> for (T, T, T, T) {
|
||||
fn from(array: UniqueEntityArray<T, 4>) -> Self {
|
||||
impl<T: TrustedEntityBorrow> From<UniqueEntityArray<4, T>> for (T, T, T, T) {
|
||||
fn from(array: UniqueEntityArray<4, T>) -> Self {
|
||||
Self::from(array.into_inner())
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow> From<UniqueEntityArray<T, 5>> for (T, T, T, T, T) {
|
||||
fn from(array: UniqueEntityArray<T, 5>) -> Self {
|
||||
impl<T: TrustedEntityBorrow> From<UniqueEntityArray<5, T>> for (T, T, T, T, T) {
|
||||
fn from(array: UniqueEntityArray<5, T>) -> Self {
|
||||
Self::from(array.into_inner())
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow> From<UniqueEntityArray<T, 6>> for (T, T, T, T, T, T) {
|
||||
fn from(array: UniqueEntityArray<T, 6>) -> Self {
|
||||
impl<T: TrustedEntityBorrow> From<UniqueEntityArray<6, T>> for (T, T, T, T, T, T) {
|
||||
fn from(array: UniqueEntityArray<6, T>) -> Self {
|
||||
Self::from(array.into_inner())
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow> From<UniqueEntityArray<T, 7>> for (T, T, T, T, T, T, T) {
|
||||
fn from(array: UniqueEntityArray<T, 7>) -> Self {
|
||||
impl<T: TrustedEntityBorrow> From<UniqueEntityArray<7, T>> for (T, T, T, T, T, T, T) {
|
||||
fn from(array: UniqueEntityArray<7, T>) -> Self {
|
||||
Self::from(array.into_inner())
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow> From<UniqueEntityArray<T, 8>> for (T, T, T, T, T, T, T, T) {
|
||||
fn from(array: UniqueEntityArray<T, 8>) -> Self {
|
||||
impl<T: TrustedEntityBorrow> From<UniqueEntityArray<8, T>> for (T, T, T, T, T, T, T, T) {
|
||||
fn from(array: UniqueEntityArray<8, T>) -> Self {
|
||||
Self::from(array.into_inner())
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow> From<UniqueEntityArray<T, 9>> for (T, T, T, T, T, T, T, T, T) {
|
||||
fn from(array: UniqueEntityArray<T, 9>) -> Self {
|
||||
impl<T: TrustedEntityBorrow> From<UniqueEntityArray<9, T>> for (T, T, T, T, T, T, T, T, T) {
|
||||
fn from(array: UniqueEntityArray<9, T>) -> Self {
|
||||
Self::from(array.into_inner())
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow> From<UniqueEntityArray<T, 10>> for (T, T, T, T, T, T, T, T, T, T) {
|
||||
fn from(array: UniqueEntityArray<T, 10>) -> Self {
|
||||
impl<T: TrustedEntityBorrow> From<UniqueEntityArray<10, T>> for (T, T, T, T, T, T, T, T, T, T) {
|
||||
fn from(array: UniqueEntityArray<10, T>) -> Self {
|
||||
Self::from(array.into_inner())
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow> From<UniqueEntityArray<T, 11>> for (T, T, T, T, T, T, T, T, T, T, T) {
|
||||
fn from(array: UniqueEntityArray<T, 11>) -> Self {
|
||||
impl<T: TrustedEntityBorrow> From<UniqueEntityArray<11, T>> for (T, T, T, T, T, T, T, T, T, T, T) {
|
||||
fn from(array: UniqueEntityArray<11, T>) -> Self {
|
||||
Self::from(array.into_inner())
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow> From<UniqueEntityArray<T, 12>>
|
||||
impl<T: TrustedEntityBorrow> From<UniqueEntityArray<12, T>>
|
||||
for (T, T, T, T, T, T, T, T, T, T, T, T)
|
||||
{
|
||||
fn from(array: UniqueEntityArray<T, 12>) -> Self {
|
||||
fn from(array: UniqueEntityArray<12, T>) -> Self {
|
||||
Self::from(array.into_inner())
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow + Ord, const N: usize> From<UniqueEntityArray<T, N>> for BTreeSet<T> {
|
||||
fn from(value: UniqueEntityArray<T, N>) -> Self {
|
||||
impl<T: TrustedEntityBorrow + Ord, const N: usize> From<UniqueEntityArray<N, T>> for BTreeSet<T> {
|
||||
fn from(value: UniqueEntityArray<N, T>) -> Self {
|
||||
BTreeSet::from(value.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow + Ord, const N: usize> From<UniqueEntityArray<T, N>> for BinaryHeap<T> {
|
||||
fn from(value: UniqueEntityArray<T, N>) -> Self {
|
||||
impl<T: TrustedEntityBorrow + Ord, const N: usize> From<UniqueEntityArray<N, T>> for BinaryHeap<T> {
|
||||
fn from(value: UniqueEntityArray<N, T>) -> Self {
|
||||
BinaryHeap::from(value.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> From<UniqueEntityArray<T, N>> for LinkedList<T> {
|
||||
fn from(value: UniqueEntityArray<T, N>) -> Self {
|
||||
impl<T: TrustedEntityBorrow, const N: usize> From<UniqueEntityArray<N, T>> for LinkedList<T> {
|
||||
fn from(value: UniqueEntityArray<N, T>) -> Self {
|
||||
LinkedList::from(value.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> From<UniqueEntityArray<T, N>> for Vec<T> {
|
||||
fn from(value: UniqueEntityArray<T, N>) -> Self {
|
||||
impl<T: TrustedEntityBorrow, const N: usize> From<UniqueEntityArray<N, T>> for Vec<T> {
|
||||
fn from(value: UniqueEntityArray<N, T>) -> Self {
|
||||
Vec::from(value.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> From<UniqueEntityArray<T, N>> for VecDeque<T> {
|
||||
fn from(value: UniqueEntityArray<T, N>) -> Self {
|
||||
impl<T: TrustedEntityBorrow, const N: usize> From<UniqueEntityArray<N, T>> for VecDeque<T> {
|
||||
fn from(value: UniqueEntityArray<N, T>) -> Self {
|
||||
VecDeque::from(value.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow + PartialEq<U>, U: TrustedEntityBorrow, const N: usize>
|
||||
PartialEq<&UniqueEntitySlice<U>> for UniqueEntityArray<T, N>
|
||||
PartialEq<&UniqueEntitySlice<U>> for UniqueEntityArray<N, T>
|
||||
{
|
||||
fn eq(&self, other: &&UniqueEntitySlice<U>) -> bool {
|
||||
self.0.eq(&other.as_inner())
|
||||
@ -482,47 +482,47 @@ impl<T: TrustedEntityBorrow + PartialEq<U>, U: TrustedEntityBorrow, const N: usi
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow + PartialEq<U>, U: TrustedEntityBorrow, const N: usize>
|
||||
PartialEq<UniqueEntitySlice<U>> for UniqueEntityArray<T, N>
|
||||
PartialEq<UniqueEntitySlice<U>> for UniqueEntityArray<N, T>
|
||||
{
|
||||
fn eq(&self, other: &UniqueEntitySlice<U>) -> bool {
|
||||
self.0.eq(other.as_inner())
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: PartialEq<U>, U: TrustedEntityBorrow, const N: usize> PartialEq<&UniqueEntityArray<U, N>>
|
||||
impl<T: PartialEq<U>, U: TrustedEntityBorrow, const N: usize> PartialEq<&UniqueEntityArray<N, U>>
|
||||
for Vec<T>
|
||||
{
|
||||
fn eq(&self, other: &&UniqueEntityArray<U, N>) -> bool {
|
||||
fn eq(&self, other: &&UniqueEntityArray<N, U>) -> bool {
|
||||
self.eq(&other.0)
|
||||
}
|
||||
}
|
||||
impl<T: PartialEq<U>, U: TrustedEntityBorrow, const N: usize> PartialEq<&UniqueEntityArray<U, N>>
|
||||
impl<T: PartialEq<U>, U: TrustedEntityBorrow, const N: usize> PartialEq<&UniqueEntityArray<N, U>>
|
||||
for VecDeque<T>
|
||||
{
|
||||
fn eq(&self, other: &&UniqueEntityArray<U, N>) -> bool {
|
||||
fn eq(&self, other: &&UniqueEntityArray<N, U>) -> bool {
|
||||
self.eq(&other.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: PartialEq<U>, U: TrustedEntityBorrow, const N: usize>
|
||||
PartialEq<&mut UniqueEntityArray<U, N>> for VecDeque<T>
|
||||
PartialEq<&mut UniqueEntityArray<N, U>> for VecDeque<T>
|
||||
{
|
||||
fn eq(&self, other: &&mut UniqueEntityArray<U, N>) -> bool {
|
||||
fn eq(&self, other: &&mut UniqueEntityArray<N, U>) -> bool {
|
||||
self.eq(&other.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: PartialEq<U>, U: TrustedEntityBorrow, const N: usize> PartialEq<UniqueEntityArray<U, N>>
|
||||
impl<T: PartialEq<U>, U: TrustedEntityBorrow, const N: usize> PartialEq<UniqueEntityArray<N, U>>
|
||||
for Vec<T>
|
||||
{
|
||||
fn eq(&self, other: &UniqueEntityArray<U, N>) -> bool {
|
||||
fn eq(&self, other: &UniqueEntityArray<N, U>) -> bool {
|
||||
self.eq(&other.0)
|
||||
}
|
||||
}
|
||||
impl<T: PartialEq<U>, U: TrustedEntityBorrow, const N: usize> PartialEq<UniqueEntityArray<U, N>>
|
||||
impl<T: PartialEq<U>, U: TrustedEntityBorrow, const N: usize> PartialEq<UniqueEntityArray<N, U>>
|
||||
for VecDeque<T>
|
||||
{
|
||||
fn eq(&self, other: &UniqueEntityArray<U, N>) -> bool {
|
||||
fn eq(&self, other: &UniqueEntityArray<N, U>) -> bool {
|
||||
self.eq(&other.0)
|
||||
}
|
||||
}
|
||||
@ -530,7 +530,7 @@ impl<T: PartialEq<U>, U: TrustedEntityBorrow, const N: usize> PartialEq<UniqueEn
|
||||
/// A by-value array iterator.
|
||||
///
|
||||
/// Equivalent to [`array::IntoIter`].
|
||||
pub type IntoIter<T, const N: usize> = UniqueEntityIter<array::IntoIter<T, N>>;
|
||||
pub type IntoIter<const N: usize, T = Entity> = UniqueEntityIter<array::IntoIter<T, N>>;
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> UniqueEntityIter<array::IntoIter<T, N>> {
|
||||
/// Returns an immutable slice of all elements that have not been yielded
|
||||
|
||||
@ -27,7 +27,8 @@ use bevy_platform_support::sync::Arc;
|
||||
use super::{
|
||||
unique_array::UniqueEntityArray,
|
||||
unique_vec::{self, UniqueEntityVec},
|
||||
EntitySet, EntitySetIterator, FromEntitySetIterator, TrustedEntityBorrow, UniqueEntityIter,
|
||||
Entity, EntitySet, EntitySetIterator, FromEntitySetIterator, TrustedEntityBorrow,
|
||||
UniqueEntityIter,
|
||||
};
|
||||
|
||||
/// A slice that contains only unique entities.
|
||||
@ -35,7 +36,7 @@ use super::{
|
||||
/// It can be obtained by slicing [`UniqueEntityVec`].
|
||||
#[repr(transparent)]
|
||||
#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
|
||||
pub struct UniqueEntitySlice<T: TrustedEntityBorrow>([T]);
|
||||
pub struct UniqueEntitySlice<T: TrustedEntityBorrow = Entity>([T]);
|
||||
|
||||
impl<T: TrustedEntityBorrow> UniqueEntitySlice<T> {
|
||||
/// Constructs a `UniqueEntitySlice` from a [`&[T]`] unsafely.
|
||||
@ -136,7 +137,7 @@ impl<T: TrustedEntityBorrow> UniqueEntitySlice<T> {
|
||||
/// Returns an array reference to the first `N` items in the slice.
|
||||
///
|
||||
/// Equivalent to [`[T]::first_chunk`](slice::first_chunk).
|
||||
pub const fn first_chunk<const N: usize>(&self) -> Option<&UniqueEntityArray<T, N>> {
|
||||
pub const fn first_chunk<const N: usize>(&self) -> Option<&UniqueEntityArray<N, T>> {
|
||||
let Some(chunk) = self.0.first_chunk() else {
|
||||
return None;
|
||||
};
|
||||
@ -149,7 +150,7 @@ impl<T: TrustedEntityBorrow> UniqueEntitySlice<T> {
|
||||
/// Equivalent to [`[T]::split_first_chunk`](slice::split_first_chunk).
|
||||
pub const fn split_first_chunk<const N: usize>(
|
||||
&self,
|
||||
) -> Option<(&UniqueEntityArray<T, N>, &UniqueEntitySlice<T>)> {
|
||||
) -> Option<(&UniqueEntityArray<N, T>, &UniqueEntitySlice<T>)> {
|
||||
let Some((chunk, rest)) = self.0.split_first_chunk() else {
|
||||
return None;
|
||||
};
|
||||
@ -167,7 +168,7 @@ impl<T: TrustedEntityBorrow> UniqueEntitySlice<T> {
|
||||
/// Equivalent to [`[T]::split_last_chunk`](slice::split_last_chunk).
|
||||
pub const fn split_last_chunk<const N: usize>(
|
||||
&self,
|
||||
) -> Option<(&UniqueEntitySlice<T>, &UniqueEntityArray<T, N>)> {
|
||||
) -> Option<(&UniqueEntitySlice<T>, &UniqueEntityArray<N, T>)> {
|
||||
let Some((rest, chunk)) = self.0.split_last_chunk() else {
|
||||
return None;
|
||||
};
|
||||
@ -183,7 +184,7 @@ impl<T: TrustedEntityBorrow> UniqueEntitySlice<T> {
|
||||
/// Returns an array reference to the last `N` items in the slice.
|
||||
///
|
||||
/// Equivalent to [`[T]::last_chunk`](slice::last_chunk).
|
||||
pub const fn last_chunk<const N: usize>(&self) -> Option<&UniqueEntityArray<T, N>> {
|
||||
pub const fn last_chunk<const N: usize>(&self) -> Option<&UniqueEntityArray<N, T>> {
|
||||
let Some(chunk) = self.0.last_chunk() else {
|
||||
return None;
|
||||
};
|
||||
@ -414,7 +415,7 @@ impl<T: TrustedEntityBorrow> UniqueEntitySlice<T> {
|
||||
/// Equivalent to [`[T]::chunk_by`].
|
||||
///
|
||||
/// [`[T]::chunk_by`]: `slice::chunk_by`
|
||||
pub fn chunk_by<F>(&self, pred: F) -> ChunkBy<'_, T, F>
|
||||
pub fn chunk_by<F>(&self, pred: F) -> ChunkBy<'_, F, T>
|
||||
where
|
||||
F: FnMut(&T, &T) -> bool,
|
||||
{
|
||||
@ -428,7 +429,7 @@ impl<T: TrustedEntityBorrow> UniqueEntitySlice<T> {
|
||||
/// Equivalent to [`[T]::chunk_by_mut`].
|
||||
///
|
||||
/// [`[T]::chunk_by_mut`]: `slice::chunk_by_mut`
|
||||
pub fn chunk_by_mut<F>(&mut self, pred: F) -> ChunkByMut<'_, T, F>
|
||||
pub fn chunk_by_mut<F>(&mut self, pred: F) -> ChunkByMut<'_, F, T>
|
||||
where
|
||||
F: FnMut(&T, &T) -> bool,
|
||||
{
|
||||
@ -548,7 +549,7 @@ impl<T: TrustedEntityBorrow> UniqueEntitySlice<T> {
|
||||
/// Equivalent to [`[T]::split`].
|
||||
///
|
||||
/// [`[T]::split`]: `slice::split`
|
||||
pub fn split<F>(&self, pred: F) -> Split<'_, T, F>
|
||||
pub fn split<F>(&self, pred: F) -> Split<'_, F, T>
|
||||
where
|
||||
F: FnMut(&T) -> bool,
|
||||
{
|
||||
@ -562,7 +563,7 @@ impl<T: TrustedEntityBorrow> UniqueEntitySlice<T> {
|
||||
/// Equivalent to [`[T]::split_mut`].
|
||||
///
|
||||
/// [`[T]::split_mut`]: `slice::split_mut`
|
||||
pub fn split_mut<F>(&mut self, pred: F) -> SplitMut<'_, T, F>
|
||||
pub fn split_mut<F>(&mut self, pred: F) -> SplitMut<'_, F, T>
|
||||
where
|
||||
F: FnMut(&T) -> bool,
|
||||
{
|
||||
@ -578,7 +579,7 @@ impl<T: TrustedEntityBorrow> UniqueEntitySlice<T> {
|
||||
/// Equivalent to [`[T]::split_inclusive`].
|
||||
///
|
||||
/// [`[T]::split_inclusive`]: `slice::split_inclusive`
|
||||
pub fn split_inclusive<F>(&self, pred: F) -> SplitInclusive<'_, T, F>
|
||||
pub fn split_inclusive<F>(&self, pred: F) -> SplitInclusive<'_, F, T>
|
||||
where
|
||||
F: FnMut(&T) -> bool,
|
||||
{
|
||||
@ -594,7 +595,7 @@ impl<T: TrustedEntityBorrow> UniqueEntitySlice<T> {
|
||||
/// Equivalent to [`[T]::split_inclusive_mut`].
|
||||
///
|
||||
/// [`[T]::split_inclusive_mut`]: `slice::split_inclusive_mut`
|
||||
pub fn split_inclusive_mut<F>(&mut self, pred: F) -> SplitInclusiveMut<'_, T, F>
|
||||
pub fn split_inclusive_mut<F>(&mut self, pred: F) -> SplitInclusiveMut<'_, F, T>
|
||||
where
|
||||
F: FnMut(&T) -> bool,
|
||||
{
|
||||
@ -612,7 +613,7 @@ impl<T: TrustedEntityBorrow> UniqueEntitySlice<T> {
|
||||
/// Equivalent to [`[T]::rsplit`].
|
||||
///
|
||||
/// [`[T]::rsplit`]: `slice::rsplit`
|
||||
pub fn rsplit<F>(&self, pred: F) -> RSplit<'_, T, F>
|
||||
pub fn rsplit<F>(&self, pred: F) -> RSplit<'_, F, T>
|
||||
where
|
||||
F: FnMut(&T) -> bool,
|
||||
{
|
||||
@ -627,7 +628,7 @@ impl<T: TrustedEntityBorrow> UniqueEntitySlice<T> {
|
||||
/// Equivalent to [`[T]::rsplit_mut`].
|
||||
///
|
||||
/// [`[T]::rsplit_mut`]: `slice::rsplit_mut`
|
||||
pub fn rsplit_mut<F>(&mut self, pred: F) -> RSplitMut<'_, T, F>
|
||||
pub fn rsplit_mut<F>(&mut self, pred: F) -> RSplitMut<'_, F, T>
|
||||
where
|
||||
F: FnMut(&T) -> bool,
|
||||
{
|
||||
@ -643,7 +644,7 @@ impl<T: TrustedEntityBorrow> UniqueEntitySlice<T> {
|
||||
/// Equivalent to [`[T]::splitn`].
|
||||
///
|
||||
/// [`[T]::splitn`]: `slice::splitn`
|
||||
pub fn splitn<F>(&self, n: usize, pred: F) -> SplitN<'_, T, F>
|
||||
pub fn splitn<F>(&self, n: usize, pred: F) -> SplitN<'_, F, T>
|
||||
where
|
||||
F: FnMut(&T) -> bool,
|
||||
{
|
||||
@ -657,7 +658,7 @@ impl<T: TrustedEntityBorrow> UniqueEntitySlice<T> {
|
||||
/// Equivalent to [`[T]::splitn_mut`].
|
||||
///
|
||||
/// [`[T]::splitn_mut`]: `slice::splitn_mut`
|
||||
pub fn splitn_mut<F>(&mut self, n: usize, pred: F) -> SplitNMut<'_, T, F>
|
||||
pub fn splitn_mut<F>(&mut self, n: usize, pred: F) -> SplitNMut<'_, F, T>
|
||||
where
|
||||
F: FnMut(&T) -> bool,
|
||||
{
|
||||
@ -673,7 +674,7 @@ impl<T: TrustedEntityBorrow> UniqueEntitySlice<T> {
|
||||
/// Equivalent to [`[T]::rsplitn`].
|
||||
///
|
||||
/// [`[T]::rsplitn`]: `slice::rsplitn`
|
||||
pub fn rsplitn<F>(&self, n: usize, pred: F) -> RSplitN<'_, T, F>
|
||||
pub fn rsplitn<F>(&self, n: usize, pred: F) -> RSplitN<'_, F, T>
|
||||
where
|
||||
F: FnMut(&T) -> bool,
|
||||
{
|
||||
@ -687,7 +688,7 @@ impl<T: TrustedEntityBorrow> UniqueEntitySlice<T> {
|
||||
/// Equivalent to [`[T]::rsplitn_mut`].
|
||||
///
|
||||
/// [`[T]::rsplitn_mut`]: `slice::rsplitn_mut`
|
||||
pub fn rsplitn_mut<F>(&mut self, n: usize, pred: F) -> RSplitNMut<'_, T, F>
|
||||
pub fn rsplitn_mut<F>(&mut self, n: usize, pred: F) -> RSplitNMut<'_, F, T>
|
||||
where
|
||||
F: FnMut(&T) -> bool,
|
||||
{
|
||||
@ -1012,10 +1013,10 @@ impl<'a, T: TrustedEntityBorrow + Clone> From<&'a UniqueEntitySlice<T>>
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow + Clone, const N: usize> From<UniqueEntityArray<T, N>>
|
||||
impl<T: TrustedEntityBorrow + Clone, const N: usize> From<UniqueEntityArray<N, T>>
|
||||
for Box<UniqueEntitySlice<T>>
|
||||
{
|
||||
fn from(value: UniqueEntityArray<T, N>) -> Self {
|
||||
fn from(value: UniqueEntityArray<N, T>) -> Self {
|
||||
// SAFETY: All elements in the original slice are unique.
|
||||
unsafe { UniqueEntitySlice::from_boxed_slice_unchecked(Box::new(value.into_inner())) }
|
||||
}
|
||||
@ -1207,25 +1208,25 @@ impl<T: TrustedEntityBorrow + PartialEq<U>, U, const N: usize> PartialEq<[U; N]>
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow + PartialEq<U>, U: TrustedEntityBorrow, const N: usize>
|
||||
PartialEq<UniqueEntityArray<U, N>> for &UniqueEntitySlice<T>
|
||||
PartialEq<UniqueEntityArray<N, U>> for &UniqueEntitySlice<T>
|
||||
{
|
||||
fn eq(&self, other: &UniqueEntityArray<U, N>) -> bool {
|
||||
fn eq(&self, other: &UniqueEntityArray<N, U>) -> bool {
|
||||
self.0.eq(&other.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow + PartialEq<U>, U: TrustedEntityBorrow, const N: usize>
|
||||
PartialEq<UniqueEntityArray<U, N>> for &mut UniqueEntitySlice<T>
|
||||
PartialEq<UniqueEntityArray<N, U>> for &mut UniqueEntitySlice<T>
|
||||
{
|
||||
fn eq(&self, other: &UniqueEntityArray<U, N>) -> bool {
|
||||
fn eq(&self, other: &UniqueEntityArray<N, U>) -> bool {
|
||||
self.0.eq(&other.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow + PartialEq<U>, U: TrustedEntityBorrow, const N: usize>
|
||||
PartialEq<UniqueEntityArray<U, N>> for UniqueEntitySlice<T>
|
||||
PartialEq<UniqueEntityArray<N, U>> for UniqueEntitySlice<T>
|
||||
{
|
||||
fn eq(&self, other: &UniqueEntityArray<U, N>) -> bool {
|
||||
fn eq(&self, other: &UniqueEntityArray<N, U>) -> bool {
|
||||
self.0.eq(&other.0)
|
||||
}
|
||||
}
|
||||
@ -1258,7 +1259,7 @@ impl<T: TrustedEntityBorrow + Clone> ToOwned for UniqueEntitySlice<T> {
|
||||
}
|
||||
|
||||
impl<'a, T: TrustedEntityBorrow + Copy, const N: usize> TryFrom<&'a UniqueEntitySlice<T>>
|
||||
for &'a UniqueEntityArray<T, N>
|
||||
for &'a UniqueEntityArray<N, T>
|
||||
{
|
||||
type Error = TryFromSliceError;
|
||||
|
||||
@ -1270,7 +1271,7 @@ impl<'a, T: TrustedEntityBorrow + Copy, const N: usize> TryFrom<&'a UniqueEntity
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow + Copy, const N: usize> TryFrom<&UniqueEntitySlice<T>>
|
||||
for UniqueEntityArray<T, N>
|
||||
for UniqueEntityArray<N, T>
|
||||
{
|
||||
type Error = TryFromSliceError;
|
||||
|
||||
@ -1280,7 +1281,7 @@ impl<T: TrustedEntityBorrow + Copy, const N: usize> TryFrom<&UniqueEntitySlice<T
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow + Copy, const N: usize> TryFrom<&mut UniqueEntitySlice<T>>
|
||||
for UniqueEntityArray<T, N>
|
||||
for UniqueEntityArray<N, T>
|
||||
{
|
||||
type Error = TryFromSliceError;
|
||||
|
||||
@ -1527,19 +1528,19 @@ impl<'a, T: TrustedEntityBorrow + 'a, I: Iterator<Item = &'a [T]> + AsRef<[&'a [
|
||||
/// An iterator over overlapping subslices of length `size`.
|
||||
///
|
||||
/// This struct is created by [`UniqueEntitySlice::windows`].
|
||||
pub type Windows<'a, T> = UniqueEntitySliceIter<'a, T, slice::Windows<'a, T>>;
|
||||
pub type Windows<'a, T = Entity> = UniqueEntitySliceIter<'a, T, slice::Windows<'a, T>>;
|
||||
|
||||
/// An iterator over a slice in (non-overlapping) chunks (`chunk_size` elements at a
|
||||
/// time), starting at the beginning of the slice.
|
||||
///
|
||||
/// This struct is created by [`UniqueEntitySlice::chunks`].
|
||||
pub type Chunks<'a, T> = UniqueEntitySliceIter<'a, T, slice::Chunks<'a, T>>;
|
||||
pub type Chunks<'a, T = Entity> = UniqueEntitySliceIter<'a, T, slice::Chunks<'a, T>>;
|
||||
|
||||
/// An iterator over a slice in (non-overlapping) chunks (`chunk_size` elements at a
|
||||
/// time), starting at the beginning of the slice.
|
||||
///
|
||||
/// This struct is created by [`UniqueEntitySlice::chunks_exact`].
|
||||
pub type ChunksExact<'a, T> = UniqueEntitySliceIter<'a, T, slice::ChunksExact<'a, T>>;
|
||||
pub type ChunksExact<'a, T = Entity> = UniqueEntitySliceIter<'a, T, slice::ChunksExact<'a, T>>;
|
||||
|
||||
impl<'a, T: TrustedEntityBorrow> UniqueEntitySliceIter<'a, T, slice::ChunksExact<'a, T>> {
|
||||
/// Returns the remainder of the original slice that is not going to be
|
||||
@ -1556,13 +1557,13 @@ impl<'a, T: TrustedEntityBorrow> UniqueEntitySliceIter<'a, T, slice::ChunksExact
|
||||
/// time), starting at the end of the slice.
|
||||
///
|
||||
/// This struct is created by [`UniqueEntitySlice::rchunks`].
|
||||
pub type RChunks<'a, T> = UniqueEntitySliceIter<'a, T, slice::RChunks<'a, T>>;
|
||||
pub type RChunks<'a, T = Entity> = UniqueEntitySliceIter<'a, T, slice::RChunks<'a, T>>;
|
||||
|
||||
/// An iterator over a slice in (non-overlapping) chunks (`chunk_size` elements at a
|
||||
/// time), starting at the end of the slice.
|
||||
///
|
||||
/// This struct is created by [`UniqueEntitySlice::rchunks_exact`].
|
||||
pub type RChunksExact<'a, T> = UniqueEntitySliceIter<'a, T, slice::RChunksExact<'a, T>>;
|
||||
pub type RChunksExact<'a, T = Entity> = UniqueEntitySliceIter<'a, T, slice::RChunksExact<'a, T>>;
|
||||
|
||||
impl<'a, T: TrustedEntityBorrow> UniqueEntitySliceIter<'a, T, slice::RChunksExact<'a, T>> {
|
||||
/// Returns the remainder of the original slice that is not going to be
|
||||
@ -1578,38 +1579,39 @@ impl<'a, T: TrustedEntityBorrow> UniqueEntitySliceIter<'a, T, slice::RChunksExac
|
||||
/// An iterator over slice in (non-overlapping) chunks separated by a predicate.
|
||||
///
|
||||
/// This struct is created by [`UniqueEntitySlice::chunk_by`].
|
||||
pub type ChunkBy<'a, T, P> = UniqueEntitySliceIter<'a, T, slice::ChunkBy<'a, T, P>>;
|
||||
pub type ChunkBy<'a, P, T = Entity> = UniqueEntitySliceIter<'a, T, slice::ChunkBy<'a, T, P>>;
|
||||
|
||||
/// An iterator over subslices separated by elements that match a predicate
|
||||
/// function.
|
||||
///
|
||||
/// This struct is created by [`UniqueEntitySlice::split`].
|
||||
pub type Split<'a, T, P> = UniqueEntitySliceIter<'a, T, slice::Split<'a, T, P>>;
|
||||
pub type Split<'a, P, T = Entity> = UniqueEntitySliceIter<'a, T, slice::Split<'a, T, P>>;
|
||||
|
||||
/// An iterator over subslices separated by elements that match a predicate
|
||||
/// function.
|
||||
///
|
||||
/// This struct is created by [`UniqueEntitySlice::split_inclusive`].
|
||||
pub type SplitInclusive<'a, T, P> = UniqueEntitySliceIter<'a, T, slice::SplitInclusive<'a, T, P>>;
|
||||
pub type SplitInclusive<'a, P, T = Entity> =
|
||||
UniqueEntitySliceIter<'a, T, slice::SplitInclusive<'a, T, P>>;
|
||||
|
||||
/// An iterator over subslices separated by elements that match a predicate
|
||||
/// function, starting from the end of the slice.
|
||||
///
|
||||
/// This struct is created by [`UniqueEntitySlice::rsplit`].
|
||||
pub type RSplit<'a, T, P> = UniqueEntitySliceIter<'a, T, slice::RSplit<'a, T, P>>;
|
||||
pub type RSplit<'a, P, T = Entity> = UniqueEntitySliceIter<'a, T, slice::RSplit<'a, T, P>>;
|
||||
|
||||
/// An iterator over subslices separated by elements that match a predicate
|
||||
/// function, limited to a given number of splits.
|
||||
///
|
||||
/// This struct is created by [`UniqueEntitySlice::splitn`].
|
||||
pub type SplitN<'a, T, P> = UniqueEntitySliceIter<'a, T, slice::SplitN<'a, T, P>>;
|
||||
pub type SplitN<'a, P, T = Entity> = UniqueEntitySliceIter<'a, T, slice::SplitN<'a, T, P>>;
|
||||
|
||||
/// An iterator over subslices separated by elements that match a
|
||||
/// predicate function, limited to a given number of splits, starting
|
||||
/// from the end of the slice.
|
||||
///
|
||||
/// This struct is created by [`UniqueEntitySlice::rsplitn`].
|
||||
pub type RSplitN<'a, T, P> = UniqueEntitySliceIter<'a, T, slice::RSplitN<'a, T, P>>;
|
||||
pub type RSplitN<'a, P, T = Entity> = UniqueEntitySliceIter<'a, T, slice::RSplitN<'a, T, P>>;
|
||||
|
||||
/// An iterator that yields `&mut UniqueEntitySlice`. Note that an entity may appear
|
||||
/// in multiple slices, depending on the wrapped iterator.
|
||||
@ -1713,13 +1715,14 @@ impl<'a, T: TrustedEntityBorrow + 'a, I: Iterator<Item = &'a mut [T]> + AsMut<[&
|
||||
/// elements at a time), starting at the beginning of the slice.
|
||||
///
|
||||
/// This struct is created by [`UniqueEntitySlice::chunks_mut`].
|
||||
pub type ChunksMut<'a, T> = UniqueEntitySliceIterMut<'a, T, slice::ChunksMut<'a, T>>;
|
||||
pub type ChunksMut<'a, T = Entity> = UniqueEntitySliceIterMut<'a, T, slice::ChunksMut<'a, T>>;
|
||||
|
||||
/// An iterator over a slice in (non-overlapping) mutable chunks (`chunk_size`
|
||||
/// elements at a time), starting at the beginning of the slice.
|
||||
///
|
||||
/// This struct is created by [`UniqueEntitySlice::chunks_exact_mut`].
|
||||
pub type ChunksExactMut<'a, T> = UniqueEntitySliceIterMut<'a, T, slice::ChunksExactMut<'a, T>>;
|
||||
pub type ChunksExactMut<'a, T = Entity> =
|
||||
UniqueEntitySliceIterMut<'a, T, slice::ChunksExactMut<'a, T>>;
|
||||
|
||||
impl<'a, T: TrustedEntityBorrow> UniqueEntitySliceIterMut<'a, T, slice::ChunksExactMut<'a, T>> {
|
||||
/// Returns the remainder of the original slice that is not going to be
|
||||
@ -1736,13 +1739,14 @@ impl<'a, T: TrustedEntityBorrow> UniqueEntitySliceIterMut<'a, T, slice::ChunksEx
|
||||
/// elements at a time), starting at the end of the slice.
|
||||
///
|
||||
/// This struct is created by [`UniqueEntitySlice::rchunks_mut`].
|
||||
pub type RChunksMut<'a, T> = UniqueEntitySliceIterMut<'a, T, slice::RChunksMut<'a, T>>;
|
||||
pub type RChunksMut<'a, T = Entity> = UniqueEntitySliceIterMut<'a, T, slice::RChunksMut<'a, T>>;
|
||||
|
||||
/// An iterator over a slice in (non-overlapping) mutable chunks (`chunk_size`
|
||||
/// elements at a time), starting at the end of the slice.
|
||||
///
|
||||
/// This struct is created by [`UniqueEntitySlice::rchunks_exact_mut`].
|
||||
pub type RChunksExactMut<'a, T> = UniqueEntitySliceIterMut<'a, T, slice::RChunksExactMut<'a, T>>;
|
||||
pub type RChunksExactMut<'a, T = Entity> =
|
||||
UniqueEntitySliceIterMut<'a, T, slice::RChunksExactMut<'a, T>>;
|
||||
|
||||
impl<'a, T: TrustedEntityBorrow> UniqueEntitySliceIterMut<'a, T, slice::RChunksExactMut<'a, T>> {
|
||||
/// Returns the remainder of the original slice that is not going to be
|
||||
@ -1759,37 +1763,39 @@ impl<'a, T: TrustedEntityBorrow> UniqueEntitySliceIterMut<'a, T, slice::RChunksE
|
||||
/// by a predicate.
|
||||
///
|
||||
/// This struct is created by [`UniqueEntitySlice::chunk_by_mut`].
|
||||
pub type ChunkByMut<'a, T, P> = UniqueEntitySliceIterMut<'a, T, slice::ChunkByMut<'a, T, P>>;
|
||||
pub type ChunkByMut<'a, P, T = Entity> =
|
||||
UniqueEntitySliceIterMut<'a, T, slice::ChunkByMut<'a, T, P>>;
|
||||
|
||||
/// An iterator over the mutable subslices of the vector which are separated
|
||||
/// by elements that match `pred`.
|
||||
///
|
||||
/// This struct is created by [`UniqueEntitySlice::split_mut`].
|
||||
pub type SplitMut<'a, T, P> = UniqueEntitySliceIterMut<'a, T, slice::SplitMut<'a, T, P>>;
|
||||
pub type SplitMut<'a, P, T = Entity> = UniqueEntitySliceIterMut<'a, T, slice::SplitMut<'a, T, P>>;
|
||||
|
||||
/// An iterator over the mutable subslices of the vector which are separated
|
||||
/// by elements that match `pred`. Unlike `SplitMut`, it contains the matched
|
||||
/// parts in the ends of the subslices.
|
||||
///
|
||||
/// This struct is created by [`UniqueEntitySlice::split_inclusive_mut`].
|
||||
pub type SplitInclusiveMut<'a, T, P> =
|
||||
pub type SplitInclusiveMut<'a, P, T = Entity> =
|
||||
UniqueEntitySliceIterMut<'a, T, slice::SplitInclusiveMut<'a, T, P>>;
|
||||
|
||||
/// An iterator over the subslices of the vector which are separated
|
||||
/// by elements that match `pred`, starting from the end of the slice.
|
||||
///
|
||||
/// This struct is created by [`UniqueEntitySlice::rsplit_mut`].
|
||||
pub type RSplitMut<'a, T, P> = UniqueEntitySliceIterMut<'a, T, slice::RSplitMut<'a, T, P>>;
|
||||
pub type RSplitMut<'a, P, T = Entity> = UniqueEntitySliceIterMut<'a, T, slice::RSplitMut<'a, T, P>>;
|
||||
|
||||
/// An iterator over subslices separated by elements that match a predicate
|
||||
/// function, limited to a given number of splits.
|
||||
///
|
||||
/// This struct is created by [`UniqueEntitySlice::splitn_mut`].
|
||||
pub type SplitNMut<'a, T, P> = UniqueEntitySliceIterMut<'a, T, slice::SplitNMut<'a, T, P>>;
|
||||
pub type SplitNMut<'a, P, T = Entity> = UniqueEntitySliceIterMut<'a, T, slice::SplitNMut<'a, T, P>>;
|
||||
|
||||
/// An iterator over subslices separated by elements that match a
|
||||
/// predicate function, limited to a given number of splits, starting
|
||||
/// from the end of the slice.
|
||||
///
|
||||
/// This struct is created by [`UniqueEntitySlice::rsplitn_mut`].
|
||||
pub type RSplitNMut<'a, T, P> = UniqueEntitySliceIterMut<'a, T, slice::RSplitNMut<'a, T, P>>;
|
||||
pub type RSplitNMut<'a, P, T = Entity> =
|
||||
UniqueEntitySliceIterMut<'a, T, slice::RSplitNMut<'a, T, P>>;
|
||||
|
||||
@ -22,7 +22,7 @@ use bevy_platform_support::sync::Arc;
|
||||
use super::{
|
||||
unique_array::UniqueEntityArray,
|
||||
unique_slice::{self, UniqueEntitySlice},
|
||||
EntitySet, FromEntitySetIterator, TrustedEntityBorrow, UniqueEntityIter,
|
||||
Entity, EntitySet, FromEntitySetIterator, TrustedEntityBorrow, UniqueEntityIter,
|
||||
};
|
||||
|
||||
/// A `Vec` that contains only unique entities.
|
||||
@ -36,7 +36,7 @@ use super::{
|
||||
/// While this type can be constructed via `Iterator::collect`, doing so is inefficient,
|
||||
/// and not recommended.
|
||||
#[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
|
||||
pub struct UniqueEntityVec<T: TrustedEntityBorrow>(Vec<T>);
|
||||
pub struct UniqueEntityVec<T: TrustedEntityBorrow = Entity>(Vec<T>);
|
||||
|
||||
impl<T: TrustedEntityBorrow> UniqueEntityVec<T> {
|
||||
/// Constructs a new, empty `UniqueEntityVec<T>`.
|
||||
@ -555,9 +555,9 @@ impl<T: TrustedEntityBorrow + PartialEq<U>, U, const N: usize> PartialEq<&[U; N]
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow + PartialEq<U>, U: TrustedEntityBorrow, const N: usize>
|
||||
PartialEq<&UniqueEntityArray<U, N>> for UniqueEntityVec<T>
|
||||
PartialEq<&UniqueEntityArray<N, U>> for UniqueEntityVec<T>
|
||||
{
|
||||
fn eq(&self, other: &&UniqueEntityArray<U, N>) -> bool {
|
||||
fn eq(&self, other: &&UniqueEntityArray<N, U>) -> bool {
|
||||
self.0.eq(&other.as_inner())
|
||||
}
|
||||
}
|
||||
@ -571,9 +571,9 @@ impl<T: TrustedEntityBorrow + PartialEq<U>, U, const N: usize> PartialEq<&mut [U
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow + PartialEq<U>, U: TrustedEntityBorrow, const N: usize>
|
||||
PartialEq<&mut UniqueEntityArray<U, N>> for UniqueEntityVec<T>
|
||||
PartialEq<&mut UniqueEntityArray<N, U>> for UniqueEntityVec<T>
|
||||
{
|
||||
fn eq(&self, other: &&mut UniqueEntityArray<U, N>) -> bool {
|
||||
fn eq(&self, other: &&mut UniqueEntityArray<N, U>) -> bool {
|
||||
self.0.eq(other.as_inner())
|
||||
}
|
||||
}
|
||||
@ -601,9 +601,9 @@ impl<T: TrustedEntityBorrow + PartialEq<U>, U, const N: usize> PartialEq<[U; N]>
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow + PartialEq<U>, U: TrustedEntityBorrow, const N: usize>
|
||||
PartialEq<UniqueEntityArray<U, N>> for UniqueEntityVec<T>
|
||||
PartialEq<UniqueEntityArray<N, U>> for UniqueEntityVec<T>
|
||||
{
|
||||
fn eq(&self, other: &UniqueEntityArray<U, N>) -> bool {
|
||||
fn eq(&self, other: &UniqueEntityArray<N, U>) -> bool {
|
||||
self.0.eq(other.as_inner())
|
||||
}
|
||||
}
|
||||
@ -711,24 +711,24 @@ impl<T: TrustedEntityBorrow> From<[T; 0]> for UniqueEntityVec<T> {
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow + Clone, const N: usize> From<&UniqueEntityArray<T, N>>
|
||||
impl<T: TrustedEntityBorrow + Clone, const N: usize> From<&UniqueEntityArray<N, T>>
|
||||
for UniqueEntityVec<T>
|
||||
{
|
||||
fn from(value: &UniqueEntityArray<T, N>) -> Self {
|
||||
fn from(value: &UniqueEntityArray<N, T>) -> Self {
|
||||
Self(Vec::from(value.as_inner().clone()))
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow + Clone, const N: usize> From<&mut UniqueEntityArray<T, N>>
|
||||
impl<T: TrustedEntityBorrow + Clone, const N: usize> From<&mut UniqueEntityArray<N, T>>
|
||||
for UniqueEntityVec<T>
|
||||
{
|
||||
fn from(value: &mut UniqueEntityArray<T, N>) -> Self {
|
||||
fn from(value: &mut UniqueEntityArray<N, T>) -> Self {
|
||||
Self(Vec::from(value.as_inner().clone()))
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> From<UniqueEntityArray<T, N>> for UniqueEntityVec<T> {
|
||||
fn from(value: UniqueEntityArray<T, N>) -> Self {
|
||||
impl<T: TrustedEntityBorrow, const N: usize> From<UniqueEntityArray<N, T>> for UniqueEntityVec<T> {
|
||||
fn from(value: UniqueEntityArray<N, T>) -> Self {
|
||||
Self(Vec::from(value.into_inner()))
|
||||
}
|
||||
}
|
||||
@ -806,7 +806,7 @@ impl<T: TrustedEntityBorrow, const N: usize> TryFrom<UniqueEntityVec<T>> for Box
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> TryFrom<UniqueEntityVec<T>>
|
||||
for Box<UniqueEntityArray<T, N>>
|
||||
for Box<UniqueEntityArray<N, T>>
|
||||
{
|
||||
type Error = UniqueEntityVec<T>;
|
||||
|
||||
@ -828,7 +828,7 @@ impl<T: TrustedEntityBorrow, const N: usize> TryFrom<UniqueEntityVec<T>> for [T;
|
||||
}
|
||||
|
||||
impl<T: TrustedEntityBorrow, const N: usize> TryFrom<UniqueEntityVec<T>>
|
||||
for UniqueEntityArray<T, N>
|
||||
for UniqueEntityArray<N, T>
|
||||
{
|
||||
type Error = UniqueEntityVec<T>;
|
||||
|
||||
@ -1043,7 +1043,7 @@ impl<T: TrustedEntityBorrow> IndexMut<RangeToInclusive<usize>> for UniqueEntityV
|
||||
///
|
||||
/// This `struct` is created by the [`IntoIterator::into_iter`] trait
|
||||
/// method on [`UniqueEntityVec`].
|
||||
pub type IntoIter<T> = UniqueEntityIter<vec::IntoIter<T>>;
|
||||
pub type IntoIter<T = Entity> = UniqueEntityIter<vec::IntoIter<T>>;
|
||||
|
||||
impl<T: TrustedEntityBorrow> UniqueEntityIter<vec::IntoIter<T>> {
|
||||
/// Returns the remaining items of this iterator as a slice.
|
||||
@ -1067,7 +1067,7 @@ impl<T: TrustedEntityBorrow> UniqueEntityIter<vec::IntoIter<T>> {
|
||||
///
|
||||
/// This struct is created by [`UniqueEntityVec::drain`].
|
||||
/// See its documentation for more.
|
||||
pub type Drain<'a, T> = UniqueEntityIter<vec::Drain<'a, T>>;
|
||||
pub type Drain<'a, T = Entity> = UniqueEntityIter<vec::Drain<'a, T>>;
|
||||
|
||||
impl<'a, T: TrustedEntityBorrow> UniqueEntityIter<vec::Drain<'a, T>> {
|
||||
/// Returns the remaining items of this iterator as a slice.
|
||||
|
||||
Loading…
Reference in New Issue
Block a user