Struct EntityRangeMut 

pub struct EntityRangeMut<'a, T, const INLINE: usize = 1> { /* private fields */ }

A mutable range of items in EntityStorage

Items outside the range are not modified, however the range itself can have its size change, which as a result will shift other items around. Any other groups in EntityStorage will be updated to reflect such changes, so in general this should be transparent.

Implementations

impl<T, const INLINE: usize> EntityRangeMut<'_, T, INLINE>

pub fn is_empty(&self) -> bool

Returns true if this range is empty

pub fn len(&self) -> usize

Get the number of items covered by this range

pub const fn range(&self) -> &Range<usize>

Returns a reference to the index range covered by this EntityRangeMut

pub fn as_immutable(&self) -> EntityRange<'_, T>

Temporarily borrow this range immutably

pub fn as_slice(&self) -> &[T]

Get this range as a slice

pub fn as_slice_mut(&mut self) -> &mut [T]

Get this range as a mutable slice

pub fn iter(&self) -> Iter<'_, T>

Get an iterator over the items covered by this range

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Get a mutable iterator over the items covered by this range

pub fn get(&self, index: usize) -> Option<&T>

Get a reference to the item at index, relative to the start of this range.

pub fn get_mut(&mut self, index: usize) -> Option<&mut T>

Get a mutable reference to the item at index, relative to the start of this range.

impl<T: StorableEntity, const INLINE: usize> EntityRangeMut<'_, T, INLINE>

pub fn push(&mut self, item: T)

Append item to storage at the end of this range

pub fn extend<I>(&mut self, operands: I)

where I: IntoIterator<Item = T>,

Append items to storage at the end of this range

pub fn erase(&mut self, index: usize) -> T

Remove the item at index in this group, and return it.

NOTE: This will panic if index is out of bounds of the group.

pub fn pop(&mut self) -> Option<T>

Remove the last item from this group, or None if empty

impl<T: StorableEntity + Copy, const INLINE: usize> EntityRangeMut<'_, T, INLINE>

pub fn clear(&mut self)

Remove all items in this range from storage, unlinking them in the process

pub fn take(&mut self) -> SmallVec<[T; INLINE]>

Remove all items in this range from storage into an owned SmallVec for further processing.

NOTE: This does not unlink the items removed from storage, the caller is expected to handle this themselves.

impl EntityRangeMut<'_, RawEntityRef<OpOperandImpl, IntrusiveLink>>

pub fn set_operands<I>( &mut self, operands: I, owner: OperationRef, context: &Context, )

where I: IntoIterator<Item = ValueRef>,

Trait Implementations

impl<T, const INLINE: usize> Index<usize> for EntityRangeMut<'_, T, INLINE>

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T, const INLINE: usize> IndexMut<usize> for EntityRangeMut<'_, T, INLINE>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a, T> IntoIterator for EntityRangeMut<'a, T>

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

type Item = &'a mut T

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.