Struct Slots

pub struct Slots<'a>(/* private fields */);

Implementations

impl<'a> Slots<'a>

pub fn new<I>(slots: I) -> Self

where I: IntoIterator<Item = (SlotKey, SharedAlignedBuffer)>,

Create a new instance from a hashmap containing existing slots.

Only slots that are present in the input can be modified. The only exception is slots for owners created during runtime and initialized with Self::add_new_contract().

“Empty” slots must still have a value in the form of an empty SharedAlignedBuffer.

pub fn new_nested_rw<'b>(&'b mut self) -> Option<Slots<'b>>

where 'a: 'b,

Create a new nested read-write slots instance.

Nested instance will integrate its changes into the parent slot when dropped (or changes can be reset with Self::reset()).

Returns None when attempted on read-only instance.

pub fn new_nested_ro<'b>(&'b self) -> Slots<'b>

where 'a: 'b,

Create a new nested read-only slots instance

pub fn add_new_contract(&mut self, owner: Address) -> bool

Add a new contract that didn’t exist before.

In contrast to contracts in Self::new(), this contract will be allowed to have any slots related to it being modified.

Returns false if a contract already exits in a map, which is also considered as an access violation.

pub fn get_code(&self, owner: Address) -> Option<SharedAlignedBuffer>

Get code for owner.

The biggest difference from Self::use_ro() is that the slot is not marked as used, instead the current code is cloned and returned.

Returns None in case of access violation or if code is missing.

pub fn use_ro(&mut self, slot_key: SlotKey) -> Option<&SharedAlignedBuffer>

Read-only access to a slot with specified owner and contract, marks it as used.

Returns None in case of access violation.

pub fn use_rw( &mut self, slot_key: SlotKey, capacity: u32, ) -> Option<(SlotIndex, &mut OwnedAlignedBuffer)>

Read-write access to a slot with specified owner and contract, marks it as used.

The returned slot is no longer accessible through Self::use_ro() or Self::use_rw() during the lifetime of this Slot instance (and can be safely turned into a pointer). The only way to get another mutable reference is to call Self::access_used_rw().

Returns None in case of access violation.

pub fn access_used_rw( &mut self, slot_index: SlotIndex, ) -> Option<&mut OwnedAlignedBuffer>

Read-write access to a slot with specified owner and contract, that is currently marked as used due to earlier call to Self::use_rw().

NOTE: Calling this method means that any pointers that might have been stored to the result of Self::use_rw() call are now invalid!

Returns None in case of access violation.

pub fn reset(&mut self)

Reset any changes that might have been done on this level

Trait Implementations

impl<'a> Debug for Slots<'a>

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

Formats the value using the given formatter.

impl<'a> Drop for Slots<'a>

fn drop(&mut self)

Executes the destructor for this type.