Struct concordium_std::StateBox

pub struct StateBox<T: Serial, S: HasStateApi> { /* private fields */ }

A pointer type for data in the state.

The actual data is lazily loaded and thereafter cached in memory.

Due to its laziness, a StateBox can be used to defer loading of data in your state. This is useful when part of your state isn’t used in every receive method.

The type parameter T is the type stored in the box. The type parameter S is the state.

Implementations

impl<T, S> StateBox<T, S> where
    T: Serial + DeserialWithState<S>,
    S: HasStateApi, 

pub fn get(&self) -> &T

Get a reference to the value.

pub fn get_mut(&mut self) -> &mut T

Get a mutable reference to the value. If the value is modified in-memory then it will be stored when the box is dropped.

pub fn replace(&mut self, new_val: T) -> T

Replace the value with the provided one. The current value is returned. Note that if the type T contains references to state, e.g., is a StateBox, then it must be deleted to avoid space leaks.

pub fn update<F, A>(&mut self, f: F) -> A where
    F: FnOnce(&mut T) -> A, 

Update the existing value with the given function. The supplied function may return some data, which is then returned by update.

Trait Implementations

impl<T: Debug + Serial, S: Debug + HasStateApi> Debug for StateBox<T, S>

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

Formats the value using the given formatter.

impl<T, S> Deletable for StateBox<T, S> where
    T: Serial + DeserialWithState<S> + Deletable,
    S: HasStateApi, 

fn delete(self)

Delete all items that this type owns in the state.

impl<S: HasStateApi, T: Serial + DeserialWithState<S>> Deref for StateBox<T, S>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<S: HasStateApi, T: Serial + DeserialWithState<S>> DerefMut for StateBox<T, S>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T, S> DeserialWithState<S> for StateBox<T, S> where
    S: HasStateApi,
    T: Serial + DeserialWithState<S>, 

fn deserial_with_state<R: Read>(state: &S, source: &mut R) -> ParseResult<Self>

Attempt to read a structure from a given source and state, failing if an error occurs during deserialization or reading.

impl<T: Serial, S: HasStateApi> Drop for StateBox<T, S>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Serial, S: HasStateApi> Serial for StateBox<T, S>

fn serial<W: Write>(&self, out: &mut W) -> Result<(), W::Err>

Attempt to write the structure into the provided writer, failing if only part of the structure could be written.

impl<T: DeserialWithState<S> + Serial, S: HasStateApi> StateClone<S> for StateBox<T, S>

unsafe fn clone_state(&self, cloned_state_api: &S) -> Self

Make a clone of the type while using the cloned_state_api.