Struct snec::ModificationScope

pub struct ModificationScope<'a, 'b, E, R> where
    E: Entry,
    R: Receiver<E>,  { /* fields omitted */ }

A drop guard for modifying data bahind a Handle using a mutable reference instead of moving in a new value.

Since Storage should notify a receiver whenever data inside of it is modified, it cannot simply hand out mutable references to the value, because that'd allow outside code to implicitly perform a silent storage modification. While ways to do so are also provided, it's heavily discouraged and reserved for special cases.

The solution to the problem is this struct: ModificationScope. It's a drop guard which is created by providing a receiver to the storage. While it has little to no differences to a mutable reference to the data inside in terms of functionality, it notifies the receiver when dropped, ensuring that it will get modified even if a panic or any other kind of early return happens.

Trait Implementations

impl<'a, 'b, E, R> AsMut<Handle<'a, E, R>> for ModificationScope<'a, 'b, E, R> where
    E: Entry,
    R: Receiver<E>, 

fn as_mut(&mut self) -> &mut Handle<'a, E, R>

Performs the conversion.

impl<'a, 'b, E, R> AsRef<Handle<'a, E, R>> for ModificationScope<'a, 'b, E, R> where
    E: Entry,
    R: Receiver<E>, 

fn as_ref(&self) -> &Handle<'a, E, R>

Performs the conversion.

impl<'a, 'b, E, R> Debug for ModificationScope<'a, 'b, E, R> where
    E: Entry,
    E::Data: Debug,
    R: Receiver<E> + Debug, 

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

Formats the value using the given formatter.

impl<'a, 'b, E, R> Deref for ModificationScope<'a, 'b, E, R> where
    E: Entry,
    R: Receiver<E>, 

type Target = E::Data

The resulting type after dereferencing.

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

Dereferences the value.

impl<'a, 'b, E, R> DerefMut for ModificationScope<'a, 'b, E, R> where
    E: Entry,
    R: Receiver<E>, 

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

Mutably dereferences the value.

impl<'a, 'b, E, R> Drop for ModificationScope<'a, 'b, E, R> where
    E: Entry,
    R: Receiver<E>, 

fn drop(&mut self)

Executes the destructor for this type.