Struct Value 

pub struct Value<T> { /* private fields */ }

A typed storage slot for serialized values.

Value<T> is a handle to a storage location that holds a serialized T. All operations are immediate syscalls — no buffering. For in-place modification with auto-flush, use load_mut().

Implementations

impl<T> Value<T>

pub fn key(&self) -> &StorageKey

Return this value’s storage key.

impl<T> Value<T>

where T: for<'a> ReadXDR<'a>,

pub fn get(&self) -> T

Deserialize and return the stored value. Aborts if the key does not exist.

pub fn try_get(&self) -> Result<T, LibraryExn>

Deserialize and return the stored value, reporting failure as Err instead of aborting (the try_ law; see the exn module docs).

The Err is exactly the exception get would have thrown: a missing key is a LibraryExn::Syscall for which is_storage_missing is true — use none_if_missing to treat just that case as an ordinary None. A value that fails to decode as T (or exceeds the no-alloc read buffer — either way, the slot was written by something other than Value<T>::set) is LibraryExn::StorageSerialization; a value of another storage type or any other syscall failure is a LibraryExn::Syscall.

impl<T> Value<T>

where T: WriteXDR,

pub fn set(&mut self, value: &T)

Serialize and store the value immediately.

pub fn try_set(&mut self, value: &T) -> Result<(), LibraryExn>

Like set, but report failure as Err instead of aborting (the try_ law; see the exn module docs). A value that fails to serialize is LibraryExn::StorageSerialization; a syscall failure is LibraryExn::Syscall. On Err the stored value is unmodified.

pub fn set_exclusive(&mut self, value: &T)

Serialize and store the value with an exclusive lock.

pub fn try_set_exclusive(&mut self, value: &T) -> Result<(), LibraryExn>

Like set_exclusive, but report failure as Err instead of aborting (the try_ law; see the exn module docs). The error contract is try_set’s. On Err the stored value is unmodified and no lock is taken.

impl<T> Value<T>

where T: WriteXDR + for<'a> ReadXDR<'a>,

pub fn load_mut(&mut self) -> ValueMut<'_, T>

Load the value and return a mutable reference to it.

Trait Implementations

impl<T: Debug> Debug for Value<T>

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

Formats the value using the given formatter.

impl<T> Deletable for Value<T>

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<T> Flaggable for Value<T>

fn flags(&self) -> StorageFlags

The storage flags the current transaction requests for this key, as seen by the current call frame: ExclusiveLock once an exclusive write or set_flags has asked for it, until clear_flags. A key with no pending write has none.

fn set_flags(&mut self, flags: StorageFlags)

Adds flags (a bitwise OR) to the key’s storage flags. Later writes through any handle keep them.

fn clear_flags(&mut self)

Removes every storage flag from the key. Does nothing if no write to it is pending.

impl<T> From<Keypath> for Value<T>

fn from(keypath: Keypath) -> Self

Converts to this type from the input type.

impl<T> StorageType for Value<T>