Struct EntityCursorMut 

pub struct EntityCursorMut<'a, T> { /* private fields */ }

A cursor which provides mutable access to an EntityList.

Implementations

impl<'a, T: EntityListItem> EntityCursorMut<'a, T>

pub fn is_null(&self) -> bool

Returns true if this cursor is pointing to the null object

pub fn get(&self) -> Option<EntityRef<'_, T>>

Get a shared reference to the entity under the cursor.

Returns None if the cursor is currently pointing to the null object.

NOTE: This binds the lifetime of the EntityRef to the cursor, to ensure that the cursor is frozen while the entity is being borrowed. This ensures that only one reference at a time is being handed out by this cursor.

pub fn get_mut(&mut self) -> Option<EntityMut<'_, T>>

Get a mutable reference to the entity under the cursor.

Returns None if the cursor is currently pointing to the null object.

Not only does this mutably borrow the cursor, the lifetime of the EntityMut is bound to that of the cursor, which means it cannot outlive the cursor, and also prevents the cursor from being accessed in any way until the mutable reference is dropped. This makes it impossible to try and alias the underlying entity using the cursor.

pub fn as_cursor(&self) -> EntityCursor<'_, T>

Returns a read-only cursor pointing to the current element.

The lifetime of the returned EntityCursor is bound to that of the EntityCursorMut, which means it cannot outlive the EntityCursorMut and that the EntityCursorMut is frozen for the lifetime of the EntityCursor.

pub fn as_pointer(&self) -> Option<UnsafeIntrusiveEntityRef<T>>

Get the [TrackedEntityHandle] corresponding to the entity under the cursor.

Returns None if the cursor is pointing to the null object.

pub fn into_borrow(self) -> Option<EntityRef<'a, T>>

Consume the cursor and convert it into a borrow of the current entity, or None if null.

pub fn into_borrow_mut(self) -> Option<EntityMut<'a, T>>

Consume the cursor and convert it into a mutable borrow of the current entity, or None if null.

pub fn move_next(&mut self)

Moves the cursor to the next element of the EntityList.

If the cursor is pointing to the null object then this will move it to the front of the EntityList. If it is pointing to the back of the EntityList then this will move it to the null object.

pub fn move_prev(&mut self)

Moves the cursor to the previous element of the EntityList.

If the cursor is pointing to the null object then this will move it to the back of the EntityList. If it is pointing to the front of the EntityList then this will move it to the null object.

pub fn peek_next(&self) -> EntityCursor<'_, T>

Returns a cursor pointing to the next element of the EntityList.

If the cursor is pointing to the null object then this will return a cursor pointing to the front of the EntityList. If it is pointing to the last entity of the EntityList then this will return a null cursor.

pub fn peek_prev(&self) -> EntityCursor<'_, T>

Returns a cursor pointing to the previous element of the EntityList.

If the cursor is pointing to the null object then this will return a cursor pointing to the last entity in the EntityList. If it is pointing to the front of the EntityList then this will return a null cursor.

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

Removes the current entity from the EntityList.

A pointer to the element that was removed is returned, and the cursor is moved to point to the next element in the [Entitylist].

If the cursor is currently pointing to the null object then nothing is removed and None is returned.

pub fn replace_with( &mut self, value: UnsafeIntrusiveEntityRef<T>, ) -> Result<UnsafeIntrusiveEntityRef<T>, UnsafeIntrusiveEntityRef<T>>

Removes the current entity from the EntityList and inserts another one in its place.

A pointer to the entity that was removed is returned, and the cursor is modified to point to the newly added entity.

If the cursor is currently pointing to the null object then Err is returned containing the entity we failed to insert.

Panics

Panics if the new entity is already linked to a different intrusive collection.

pub fn insert_after(&mut self, value: UnsafeIntrusiveEntityRef<T>)

Inserts a new entity into the EntityList, after the current cursor position.

If the cursor is pointing at the null object then the entity is inserted at the start of the underlying EntityList.

Panics

Panics if the entity is already linked to a different EntityList

pub fn insert_before(&mut self, value: UnsafeIntrusiveEntityRef<T>)

Inserts a new entity into the EntityList, before the current cursor position.

If the cursor is pointing at the null object then the entity is inserted at the end of the underlying EntityList.

Panics

Panics if the entity is already linked to a different EntityList

pub fn splice_after(&mut self, list: EntityList<T>)

This splices list into the underlying list of self by inserting the elements of list after the current cursor position.

For example, let’s say we have the following list and cursor position:

[A, B, C]
    ^-- cursor

Splicing a new list, [D, E, F] after the cursor would result in:

[A, B, D, E, F, C]
    ^-- cursor

If the cursor is pointing at the null object, then list is appended to the start of the underlying EntityList for this cursor.

pub fn splice_before(&mut self, list: EntityList<T>)

This splices list into the underlying list of self by inserting the elements of list before the current cursor position.

For example, let’s say we have the following list and cursor position:

[A, B, C]
    ^-- cursor

Splicing a new list, [D, E, F] before the cursor would result in:

[A, D, E, F, B, C]
             ^-- cursor

If the cursor is pointing at the null object, then list is appended to the end of the underlying EntityList for this cursor.

pub fn split_after(&mut self) -> EntityList<T>

Splits the list into two after the current cursor position.

This will return a new list consisting of everything after the cursor, with the original list retaining everything before.

If the cursor is pointing at the null object then the entire contents of the EntityList are moved.

pub fn split_before(&mut self) -> EntityList<T>

Splits the list into two before the current cursor position.

This will return a new list consisting of everything before the cursor, with the original list retaining everything after.

If the cursor is pointing at the null object then the entire contents of the EntityList are moved.