Struct pin_array::PinArray

pub struct PinArray<T, const SIZE: usize> { /* private fields */ }

A structurally pinned array of values

Implementations

impl<T, const SIZE: usize> PinArray<T, SIZE>

pub fn new(elements: [T; SIZE]) -> Self

Create a new PinArray from elements

pub const fn len(&self) -> usize

Get the length of the PinArray

assert_eq!(PinArray::new(['a', 'b', 'c']).len(), 3);

pub const fn is_empty(&self) -> bool

Check if the array is empty

assert!(PinArray::<u32, 0>::new([]).is_empty());

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

Attempt to get a reference to an element by index

Note this does not require Pin as a reference is trivially Unpin

let p = pin!(PinArray::new([1, 2, 3]));
assert_eq!(p.get(0), Some(&1));
assert_eq!(p.get(1), Some(&2));
assert_eq!(p.get(2), Some(&3));

pub fn get_pin(self: Pin<&mut Self>, idx: usize) -> Option<Pin<&mut T>>

Attempt to get a pinned reference to an element by index

Note this requires self to be pinned

let mut p = pin!(PinArray::new([1, 2, 3]));
assert_eq!(p.as_mut().get_pin(0), Some(Pin::new(&mut 1)));
assert_eq!(p.as_mut().get_pin(1), Some(Pin::new(&mut 2)));
assert_eq!(p.as_mut().get_pin(2), Some(Pin::new(&mut 3)));

pub fn as_ref_array(&self) -> [&T; SIZE]

Convert this PinArray to an array of references

Immutable counterpart to PinArray::as_pin_array

let p = pin!(PinArray::new(["a", "b"]));
assert_eq!(p.as_ref_array(), [&"a", &"b"]);

pub fn as_pin_array<'me>(self: Pin<&'me mut Self>) -> [Pin<&'me mut T>; SIZE]

Convert this pinned PinArray to an array of pinned mutable references

Mutable counterpart to PinArray::as_ref_array

let mut p = pin!(PinArray::new(["a", "b"]));
assert_eq!(p.as_pin_array(), [Pin::new(&mut "a"), Pin::new(&mut "b")]);

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

Get an iterator over references to the elements

let p = pin!(PinArray::new(['h', 'i']));
let mut i = p.iter();
assert_eq!(i.next(), Some(&'h'));
assert_eq!(i.next(), Some(&'i'));
assert_eq!(i.next(), None);

pub fn iter_mut(self: Pin<&mut Self>) -> IterMut<'_, T, SIZE>

Get an iterator over pinned mutable references to the elements

let mut p = pin!(PinArray::new(['h', 'i']));
let mut i = p.iter_mut();
assert_eq!(i.next(), Some(Pin::new(&mut 'h')));
assert_eq!(i.next(), Some(Pin::new(&mut 'i')));
assert_eq!(i.next(), None);

Trait Implementations

impl<T: Clone, const SIZE: usize> Clone for PinArray<T, SIZE>

fn clone(&self) -> PinArray<T, SIZE>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, const SIZE: usize> Debug for PinArray<T, SIZE>

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

Formats the value using the given formatter.

impl<T: Default, const SIZE: usize> Default for PinArray<T, SIZE>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Hash, const SIZE: usize> Hash for PinArray<T, SIZE>

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<T: Ord, const SIZE: usize> Ord for PinArray<T, SIZE>

fn cmp(&self, other: &PinArray<T, SIZE>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<T: PartialEq, const SIZE: usize> PartialEq for PinArray<T, SIZE>

fn eq(&self, other: &PinArray<T, SIZE>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialOrd, const SIZE: usize> PartialOrd for PinArray<T, SIZE>

fn partial_cmp(&self, other: &PinArray<T, SIZE>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Copy, const SIZE: usize> Copy for PinArray<T, SIZE>

impl<T: Eq, const SIZE: usize> Eq for PinArray<T, SIZE>

impl<T, const SIZE: usize> StructuralPartialEq for PinArray<T, SIZE>

impl<T: Unpin, const SIZE: usize> Unpin for PinArray<T, SIZE>