Struct Block16 

pub struct Block16<T> { /* private fields */ }

A fixed block of optionals masked by a u16, which may thus contain at most 16 elements.

Implementations

impl<T> Block16<T>

pub const CAPACITY: u32 = 16u32

Maximum capacity of the fixed-size block.

pub const fn new() -> Self

Creates a new empty block. Useful in const contexts.

pub const fn is_vacant(&self, index: usize) -> bool

Checks whether the item at the index is vacant (i.e. contains None).

Panic

Panics if index >= CAPACITY. See the maximum capacity.

pub const fn len(&self) -> u32

Returns the number of non-null elements in the block.

pub const fn is_empty(&self) -> bool

Returns true if the block contains zero elements.

pub const unsafe fn get_unchecked(&self, index: usize) -> &T

Returns an immutable reference to the value at index. See the get method for the safe, checked version of this method.

Safety

The queried value must be properly initialized. Otherwise, the behavior is undefined.

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

Attempts to retrieve a shared reference to the element at index. Returns None if the slot is vacant (i.e. uninitialized).

Panic

Panics if index >= CAPACITY. See the maximum capacity.

pub const unsafe fn get_unchecked_mut(&mut self, index: usize) -> &mut T

Returns a mutable reference to the value at index. See the get_mut method for the safe, checked version of this method.

Safety

The queried value must be properly initialized. Otherwise, the behavior is undefined.

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

Attempts to retrieve an exclusive reference to the element at index. Returns None if the slot is vacant (i.e. uninitialized).

Panic

Panics if index >= CAPACITY. See the maximum capacity.

pub fn get_or_else(&mut self, index: usize, func: impl FnOnce() -> T) -> &mut T

If the slot at the given index is already occupied, this method returns a mutable reference to the inner data. Otherwise, if the slot is vacant, then this method inserts the value constructed by func. A mutable reference to the inner data is nevertheless returned.

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

Convenience wrapper for the get_or_else method.

pub const fn lowest_occupied_index(&self) -> Option<u32>

Returns the index of the first (i.e., lowest index) non-vacant element in the block. Note that a u32 is returned for maximum flexibility, but its value will never exceed Self::CAPACITY. It should be safe to cast to a usize without loss of information. You may also safely unwrap the conversion via the TryFrom trait.

pub const fn first_occupied(&self) -> Option<&T>

Returns a shared reference to the first non-vacant element in the block. Convenience wrapper around Self::lowest_occupied_index followed by Self::get_unchecked.

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

Returns an exclusive reference to the first non-vacant element in the block. Convenience wrapper around Self::lowest_occupied_index followed by Self::get_unchecked_mut.

pub const fn highest_occupied_index(&self) -> Option<u32>

Returns the index of the last (i.e., highest index) non-vacant element in the block. Note that a u32 is returned for maximum flexibility, but its value will never exceed Self::CAPACITY. It should be safe to cast to a usize without loss of information. You may also safely unwrap the conversion via the TryFrom trait.

pub const fn last_occupied(&self) -> Option<&T>

Returns a shared reference to the last non-vacant element in the block. Convenience wrapper around Self::highest_occupied_index followed by Self::get_unchecked.

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

Returns an exclusive reference to the last non-vacant element in the block. Convenience wrapper around Self::highest_occupied_index followed by Self::get_unchecked_mut.

pub const fn lowest_vacant_index(&self) -> Option<u32>

Returns the index of the first (i.e., lowest index) vacant element in the block. Note that a u32 is returned for maximum flexibility, but its value will never exceed Self::CAPACITY. It should be safe to cast to a usize without loss of information. You may also safely unwrap the conversion via the TryFrom trait.

pub const fn insert_at_first_vacancy( &mut self, value: T, ) -> Result<Option<T>, T>

Attempts to insert value at the first vacant slot in the block. Convenience wrapper around Self::lowest_vacant_index followed by Self::insert.

Return Value

• Ok(option) if a vacant slot was found, where option is the return value from Self::insert.
• Err(value) if the block is full, returning the original value back to the caller.

pub const fn highest_vacant_index(&self) -> Option<u32>

Returns the index of the last (i.e., highest index) vacant element in the block. Note that a u32 is returned for maximum flexibility, but its value will never exceed Self::CAPACITY. It should be safe to cast to a usize without loss of information. You may also safely unwrap the conversion via the TryFrom trait.

pub const fn insert_at_last_vacancy(&mut self, value: T) -> Result<Option<T>, T>

Attempts to insert value at the last vacant slot in the block. Convenience wrapper around Self::highest_vacant_index followed by Self::insert.

Return Value

• Ok(option) if a vacant slot was found, where option is the return value from Self::insert.
• Err(value) if the block is full, returning the original value back to the caller.

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

Inserts the value at the index. If a value already exists, it returns Some containing the old value. Otherwise, it returns None.

Panic

Panics if index >= CAPACITY. See the maximum capacity.

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

Removes the value at the index. If a value already exists, it returns Some containing that value. Otherwise, it returns None.

Panic

Panics if index >= CAPACITY. See the maximum capacity.

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

Create a by-reference iterator for this block.

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

Create a mutable by-reference iterator for this block.

impl<T: Default> Block16<T>

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

Convenience wrapper for the get_or_else method.

Trait Implementations

impl<T: Clone> Clone for Block16<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Block16<T>

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

Formats the value using the given formatter.

impl<T> Default for Block16<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Drop for Block16<T>

Ensure that all remaining items in the block are dropped. Since the implementation internally uses MaybeUninit, we must manually drop the valid (i.e., initialized) contents ourselves.

fn drop(&mut self)

Executes the destructor for this type.

impl<T> From<[T; 16]> for Block16<T>

Create a fully initialized direct-access table.

fn from(vals: [T; 16]) -> Self

Converts to this type from the input type.

impl<T> FromIterator<(usize, T)> for Block16<T>

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = (usize, T)>,

Creates a value from an iterator.

impl<T> Index<usize> for Block16<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for Block16<T>

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

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

impl<'a, T> IntoIterator for &'a Block16<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Block16Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Block16<T>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = Block16IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> IntoIterator for Block16<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = Block16IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.