Struct RefsArrayLeftMost

pub struct RefsArrayLeftMost<const N: usize, V>
where
    V: Variant,
{ /* private fields */ }

A constant number of left-aligned references.

It differs from RefsArray due to its additional requirement that:

• all Some references are to the left of all None references.

Implementations

impl<const N: usize, V: Variant> RefsArrayLeftMost<N, V>

pub fn len(&self) -> usize

Returns the number of references.

pub fn is_empty(&self) -> bool

Returns true if the number of references is zero.

pub fn get(&self, ref_idx: usize) -> Option<&NodePtr<V>>

Returns a reference to the node pointer at the ref_idx position of the references array.

pub fn as_slice(&self) -> &[Option<NodePtr<V>>]

Returns the optional node pointers as a slice such that:

• length of the slice is equal to self.len(),
• all elements of the slice are of Some variant, and hence,
• can be safely unwrapped to access the node pointer.

pub fn iter(&self) -> ArrayLeftMostPtrIter<'_, V>

Creates an iterator over node pointers of the references collection.

pub fn iter_mut(&mut self) -> ArrayLeftMostPtrIterMut<'_, V>

Creates a mutable iterator over node pointers of the references collection.

pub fn has_room(&self) -> bool

Returns whether or not the collection has room for another reference.

pub fn push(&mut self, node_ptr: NodePtr<V>)

Pushes the node references to the end of the references collection.

Panics

Panics if the array already has N references; i.e., when self.has_room() is false.

pub fn insert(&mut self, position: usize, node_ptr: NodePtr<V>)

Inserts the reference with the given node_ptr to the given position of the references collection.

pub fn push_before( &mut self, pivot_ptr: &NodePtr<V>, node_ptr: NodePtr<V>, ) -> Option<usize>

Inserts the reference with the given node_ptr just before the given pivot_ptr the reference if it exists; and returns the position that the new reference is inserted to.

Does nothing leaving the children unchanged if the pivot_ptr reference does not exists, and returns None.

pub fn push_after( &mut self, pivot_ptr: &NodePtr<V>, node_ptr: NodePtr<V>, ) -> Option<usize>

Inserts the reference with the given node_ptr just after the given pivot_ptr the reference if it exists; and returns the position that the new reference is inserted to.

Does nothing leaving the children unchanged if the pivot_ptr reference does not exists, and returns None.

pub fn replace_with( &mut self, old_node_ptr: &NodePtr<V>, new_node_ptr: NodePtr<V>, ) -> Option<usize>

Replaces the node reference old_node_ptr with the new_node_ptr and returns the position of the reference.

Does nothing and returns None if the old_node_ptr is absent.

Trait Implementations

impl<const N: usize, V: Variant> Clone for RefsArrayLeftMost<N, V>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const N: usize, V: Variant> Debug for RefsArrayLeftMost<N, V>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const N: usize, V> Refs for RefsArrayLeftMost<N, V>

where V: Variant,

fn empty() -> Self

Creates an empty references.

fn is_empty(&self) -> bool

Returns true if the references collection is empty.

fn clear(&mut self)

Clears the references.

fn remove_at(&mut self, ref_idx: usize)

Removes the reference at the given ref_idx.

fn remove(&mut self, ptr: usize) -> Option<usize>

Removes the node reference from references pointing to the node at given ptr location.