Struct Array 

pub struct Array<S, const N: usize> { /* private fields */ }

A fixed-length array of N storage slots of type S.

Element i lives at the array’s keypath extended by i as a u32 — the same slot Map<u32, S> at that keypath would use for key i, so the two layouts are interchangeable. Like Map, an Array holds only its own keypath and derives an element’s key when the element is accessed, so its size and load cost do not depend on N. Unlike Map, the length is known at compile time: indexing is bounds-checked without a storage read, and the array can enumerate (iterate and delete) its elements.

Unlike Vector, there is no stored length: every index in 0..N is always in bounds, and an element that was never written (or was deleted) reads back as missing. Read with try_get + none_if_missing when an element may be unset. Elements share no storage, so writes to distinct elements never conflict with each other.

N must fit in a u32; a larger N fails to compile on first use.

Implementations

impl<S, const N: usize> Array<S, N>

pub const LEN: u32

The array’s length, N.

pub fn keypath(&self) -> &Keypath

pub const fn len(&self) -> u32

The array’s length, N. Never reads storage.

pub const fn is_empty(&self) -> bool

Returns true if N == 0.

impl<S: StorageType, const N: usize> Array<S, N>

pub fn at(&self, index: u32) -> SlotRef<'_, Self, S>

Borrow element at index (bounds-checked).

pub fn at_mut(&mut self, index: u32) -> SlotMut<'_, Self, S>

Mutably borrow element at index (bounds-checked).

pub fn at_mut_exclusive(&mut self, index: u32) -> SlotMut<'_, Self, S>

Like at_mut, but every successful write through the returned handle is followed by a request for an exclusive lock on the element. See Map::at_mut_exclusive.

pub fn at_disjoint_mut<const M: usize>( &mut self, indices: [u32; M], ) -> DisjointMut<'_, Self, S, M>

Mutably borrow M elements at once (bounds-checked). Panics if any indices are equal.

See Map::at_disjoint_mut.

pub fn iter(&self) -> ArrayIter<'_, S, N>

Iterate over all N elements. Yields read-only SlotRef handles, deriving each element’s key as it is reached.

pub fn iter_mut(&mut self) -> ArrayIterMut<'_, S, N>

Iterate over all N elements with mutable access. Holds an exclusive borrow on the array.

impl<S: StorageType + Deletable, const N: usize> Array<S, N>

pub fn delete_at(&mut self, index: u32)

Delete the storage of the element at index (bounds-checked). The element reads back as missing afterwards.

Trait Implementations

impl<S, const N: usize> Debug for Array<S, N>

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

Formats the value using the given formatter.

impl<S: StorageType + Deletable, const N: usize> Deletable for Array<S, N>

fn delete_internal(&mut self, exclusive: bool)

Delete storage for this node.

fn delete(&mut self)

Delete using the keypath’s own locking semantics.

fn delete_exclusive(&mut self)

Delete, then request an exclusive lock, regardless of keypath flag. Later writes in the transaction keep the lock.

impl<S, const N: usize> From<Keypath> for Array<S, N>

fn from(keypath: Keypath) -> Self

Converts to this type from the input type.

impl<'a, S: StorageType, const N: usize> IntoIterator for &'a Array<S, N>

type Item = SlotRef<'a, Array<S, N>, S>

The type of the elements being iterated over.

type IntoIter = ArrayIter<'a, S, N>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, S: StorageType, const N: usize> IntoIterator for &'a mut Array<S, N>

type Item = SlotMut<'a, Array<S, N>, S>

The type of the elements being iterated over.

type IntoIter = ArrayIterMut<'a, S, N>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<S, const N: usize> StorageType for Array<S, N>