Struct ArrayHandler 

pub struct ArrayHandler<T: StorableType, const N: usize> {
    base_slot: U256,
    address: Address,
    cache: HandlerCache<usize, T::Handler>,
}

Type-safe handler for accessing fixed-size arrays [T; N] in storage.

Unlike VecHandler, arrays have a fixed compile-time size and store elements directly at the base slot (not at keccak256(base_slot)).

Element Access

Use at(index) to get a Slot<T> for individual element operations:

• For packed elements (T::BYTES ≤ 16): returns a packed Slot<T> with byte offsets
• For unpacked elements: returns a full Slot<T> for the element’s dedicated slot
• Returns None if index is out of bounds

Example

let handler = <[u8; 32] as StorableType>::handle(base_slot, LayoutCtx::FULL);

// Full array operations
let array = handler.read()?;
handler.write([1; 32])?;

// Individual element operations
if let Some(slot) = handler[0] {
    let elem = slot.read()?;
    slot.write(42)?;
}

Fields

base_slot: U256

address: Address

cache: HandlerCache<usize, T::Handler>

Implementations

impl<T: StorableType, const N: usize> ArrayHandler<T, N>

pub fn new(base_slot: U256, address: Address) -> Self

Creates a new handler for the array at the given base slot and address.

fn as_slot(&self) -> Slot<[T; N]>

Returns a Slot accessor for full-array operations.

pub fn base_slot(&self) -> U256

Returns the base storage slot where this array’s data is stored.

Single-slot arrays pack all fields into this slot. Multi-slot arrays use consecutive slots starting from this base.

pub const fn len(&self) -> usize

Returns the array size (known at compile time).

pub const fn is_empty(&self) -> bool

Returns whether the array is empty (always false for N > 0).

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

Returns a Handler for the element at the given index.

The returned handler automatically handles packing based on T::BYTES. The handler is computed on first access and cached for subsequent accesses.

Returns None if the index is out of bounds (>= N).

fn compute_handler( base_slot: U256, address: Address, index: usize, ) -> T::Handler

Computes the handler for a given index (unchecked).

Trait Implementations

impl<T: Clone + StorableType, const N: usize> Clone for ArrayHandler<T, N>

where T::Handler: Clone,

fn clone(&self) -> ArrayHandler<T, N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + StorableType, const N: usize> Debug for ArrayHandler<T, N>

where T::Handler: Debug,

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

Formats the value using the given formatter.

impl<T: StorableType, const N: usize> Handler<[T; N]> for ArrayHandler<T, N>

where [T; N]: Storable,

fn read(&self) -> Result<[T; N]>

Reads the entire array from storage.

fn write(&mut self, value: [T; N]) -> Result<()>

Writes the entire array to storage.

fn delete(&mut self) -> Result<()>

Deletes the entire array from storage (clears all elements).

fn t_read(&self) -> Result<[T; N]>

Reads the entire array from transient storage.

fn t_write(&mut self, value: [T; N]) -> Result<()>

Writes the entire array to transient storage.

fn t_delete(&mut self) -> Result<()>

Deletes the entire array from transient storage (clears all elements).

impl<T: StorableType, const N: usize> Index<usize> for ArrayHandler<T, N>

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

Returns a reference to the cached handler for the given index.

WARNING: Panics if OOB. Caller must ensure that the index is valid. For gracefully checked access use .at(index) instead.

type Output = <T as StorableType>::Handler

The returned type after indexing.

impl<T: StorableType, const N: usize> IndexMut<usize> for ArrayHandler<T, N>

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

Returns a mutable reference to the cached handler for the given index.

WARNING: Panics if OOB. Caller must ensure that the index is valid. For gracefully checked access use .at(index) instead.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 112 bytes