Skip to content
Aptos Documentation

slots_storage - [mainnet]

use 0x1::table;
enum Link<T: store> has store
Variants
Some
Fields
value: T
Empty
Fields
next: u64

Constants

const NULL_INDEX: u64 = 0;

Structs

SlotsStorage

struct SlotsStorage<T: store> has store
Fields
slots: table::Table<u64, slots_storage::Link<T>>
new_slot_index: u64
never_deallocate: bool
reuse_head_index: u64

TransientSlot

struct TransientSlot
Fields
slot_index: u64

Functions

new_storage_slots

public fun new_storage_slots<T: store>(): slots_storage::SlotsStorage<T>
Implementation 
public fun new_storage_slots<T: store>(): SlotsStorage<T> {
    SlotsStorage {
        slots: table::new(),
        new_slot_index: 1,
        never_deallocate: false,
        reuse_head_index: NULL_INDEX,
    }
}

add

public fun add<T: store>(self: &mut slots_storage::SlotsStorage<T>, val: T): u64
Implementation 
public fun add<T: store>(self: &mut SlotsStorage<T>, val: T): u64 {
    let slot_index = self.new_slot_index;
    self.new_slot_index = self.new_slot_index + 1;
    self.slots.add(slot_index, Link::Some { value: val });
    slot_index
}

remove

public fun remove<T: store>(self: &mut slots_storage::SlotsStorage<T>, slot_index: u64): T
Implementation 
public fun remove<T: store>(self: &mut SlotsStorage<T>, slot_index: u64): T {
    let Link::Some { value } = self.slots.remove(slot_index);
    value
}

destroy_empty

public fun destroy_empty<T: store>(self: slots_storage::SlotsStorage<T>)
Implementation 
public fun destroy_empty<T: store>(self: SlotsStorage<T>) {
    let SlotsStorage {
        slots,
        new_slot_index: _,
        never_deallocate: _,
        reuse_head_index: _,
    } = self;
    slots.destroy_empty();
}

borrow

public fun borrow<T: store>(self: &slots_storage::SlotsStorage<T>, slot_index: u64): &T
Implementation 
public fun borrow<T: store>(self: &SlotsStorage<T>, slot_index: u64): &T {
    &self.slots.borrow(slot_index).value
}

borrow_mut

public fun borrow_mut<T: store>(self: &mut slots_storage::SlotsStorage<T>, slot_index: u64): &mut T
Implementation 
public fun borrow_mut<T: store>(self: &mut SlotsStorage<T>, slot_index: u64): &mut T {
    &mut self.slots.borrow_mut(slot_index).value
}

get_index

public fun get_index(self: &slots_storage::TransientSlot): u64
Implementation 
public fun get_index(self: &TransientSlot): u64 {
    self.slot_index
}

create_transient_slot

public fun create_transient_slot<T: store>(self: &mut slots_storage::SlotsStorage<T>): slots_storage::TransientSlot
Implementation 
public fun create_transient_slot<T: store>(self: &mut SlotsStorage<T>): TransientSlot {
    let slot_index = self.new_slot_index;
    self.new_slot_index = self.new_slot_index + 1;
    TransientSlot {
        slot_index,
    }
}

add_transient_slot

public fun add_transient_slot<T: store>(self: &mut slots_storage::SlotsStorage<T>, slot: slots_storage::TransientSlot, val: T)
Implementation 
public fun add_transient_slot<T: store>(self: &mut SlotsStorage<T>, slot: TransientSlot, val: T) {
    let TransientSlot { slot_index } = slot;
    self.slots.add(slot_index, Link::Some { value: val });
}

transiently_remove

public fun transiently_remove<T: store>(self: &mut slots_storage::SlotsStorage<T>, slot_index: u64): (slots_storage::TransientSlot, T)
Implementation 
public fun transiently_remove<T: store>(self: &mut SlotsStorage<T>, slot_index: u64): (TransientSlot, T) {
    let Link::Some { value } = self.slots.remove(slot_index);
    (TransientSlot { slot_index }, value)
}

destroy_transient_slot

public fun destroy_transient_slot(self: slots_storage::TransientSlot)
Implementation 
public fun destroy_transient_slot(self: TransientSlot) {
    let TransientSlot { slot_index: _ } = self;
}