Struct option_block::Block64

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

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

Implementations

impl<T> Block64<T>

pub const CAPACITY: u32 = 64u32

Maximum capacity of the fixed-size block.

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

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

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 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 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 also returned.

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

Convenience wrapper for the get_or_else method.

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

Inserts the val 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 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) -> Block64Iter<'_, T>

impl<T: Default> Block64<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 Block64<T>

Since the current implementation relies on MaybeUninit, the block can only be cloned if the internal data is trivially copyable (bitwise). It is necessary that the type does not implement Drop.

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Block64<T>

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

Formats the value using the given formatter.

impl<T> Default for Block64<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Drop for Block64<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; 64]> for Block64<T>

Create a fully initialized direct-access table.

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

Converts to this type from the input type.

impl<T> FromIterator<(usize, T)> for Block64<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 Block64<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 Block64<T>

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

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

impl<T> IntoIterator for Block64<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = Block64IntoIter<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 Block64<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Block64Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.