Struct Array256 

pub struct Array256<S> { /* private fields */ }

A sparse array of 256 elements.

Indexed by Bitset256 and backed by a configurable ArrayStorage, which is a contiguous chunk of memory holding up to 256 values.

Implementations

impl<S> Array256<S>

where S: ConstEmptyArrayStorage,

pub const EMPTY: Self

The empty array.

impl<S> Array256<S>

where S: ArrayStorage,

pub fn test(&self, index: u8) -> bool

Check if the specified index is occupied.

pub fn intersects(&self, other: &Bitset256) -> bool

Check whether this array’s occupancy intersects with the given bitset.

pub fn intersection_top(&self, other: &Bitset256) -> Option<u8>

Check whether this array’s occupancy intersects with the given bitset, and if so, the highest set bit of that intersection.

pub const fn is_empty(&self) -> bool

Return whether this array has no elements.

pub fn len(&self) -> usize

where S: AsRef<[S::T]>,

Get the number of items in this array.

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

where S: AsRef<[S::T]>,

Get a reference to the element at the specified index, if there is one.

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

where S: AsMut<[S::T]>,

Get a mutable reference to the element at the specified index, if there is one.

pub fn insert(&mut self, index: u8, element: S::T) -> Option<S::T>

where S: AsMut<[S::T]>,

Insert an item at the specified index. Returns the previous occupant if there was one.

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

where S: AsRef<[S::T]>,

Remove an item by index.

pub fn clear(&mut self)

Clear the array.

pub const fn bitset(&self) -> &Bitset256

Get a reference to the internal Bitset256 which stores the occupied storage indices.

pub fn iter(&self) -> impl Iterator<Item = (u8, &S::T)>

where S: AsRef<[S::T]>,

Iterate over all occupied entries in the array.

pub fn iter_after(&self, n: u8) -> impl Iterator<Item = (u8, &S::T)>

where S: AsRef<[S::T]>,

Iterate over occupied entries in the array starting after index n.

pub fn iter_mut(&mut self) -> impl Iterator<Item = (u8, &mut S::T)>

where S: AsMut<[S::T]>,

Iterate over mutable references to all occupied entries in the array.

pub fn custom_storage_fmt<'slf, 'f, U>( &'slf self, f: &'f dyn Fn(&'slf S::T) -> U, ) -> impl Debug + 'slf

where U: Debug + 'slf, S: AsRef<[S::T]>, 'f: 'slf,

Provide a Debug instance for this value when T is not necessarily Debug.

pub fn clone_with(&self, f: &dyn Fn(&S::T) -> S::T) -> Self

where S: FromIterator<S::T> + AsRef<[S::T]>,

Clone self with a custom function supporting clone of &T.

Trait Implementations

impl<S: Clone> Clone for Array256<S>

fn clone(&self) -> Array256<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S> Debug for Array256<S>

where S: ArrayStorage + AsRef<[S::T]>, S::T: Debug,

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

Formats the value using the given formatter.

impl<S> Default for Array256<S>

where S: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<S: Eq> Eq for Array256<S>

impl<S> FromIterator<(u8, <S as ArrayStorage>::T)> for Array256<S>

where S: ConstEmptyArrayStorage + AsMut<[S::T]>,

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

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

Creates a value from an iterator.

impl<S: Hash> Hash for Array256<S>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<S> Index<u8> for Array256<S>

where S: ArrayStorage + AsRef<[S::T]>,

type Output = <S as ArrayStorage>::T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<S> IndexMut<u8> for Array256<S>

where S: ArrayStorage + AsRef<[S::T]> + AsMut<[S::T]>,

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

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

impl<S: PartialEq> PartialEq for Array256<S>

fn eq(&self, other: &Array256<S>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S> StructuralPartialEq for Array256<S>