Struct snec::Handle

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

A handle to a config entry value which is being watched by a receiver.

Such handles not only have the semantics of managing a value for a specific field, they also automatically notify the receiver whenever the value changes.

Implementations

impl<'a, E: Entry, R: Receiver<E>> Handle<'a, E, R>

pub fn new(target: &'a mut E::Data, receiver: R) -> Self

Creates a handle pointing to the specified value and with the specified receiver.

pub fn set(&mut self, new_value: E::Data)

Sets the handle's pointee to the specified value, notifying the receiver.

For large values where partial modification using a mutable reference would improve performance (Vec is a good example of such a type), modify or modify_with should be used instead.

pub fn modify<'b>(&'b mut self) -> ModificationScope<'a, 'b, E, R>

Creates a ModificationScope for modifying the value inside without reallocating/moving and without a closure, while still notifying the receiver when modification is finished. The resulting ModificationScope acts like a mutable reference to the stored data, which allows direct modification.

modify_with may be used instead. For small values like integers, set might be faster.

pub fn modify_with<F>(&mut self, f: F) where
    F: FnMut(&mut E::Data), 

Modifies the handle's pointee using the specified closure, notifying the receiver.

modify may be used instead, for simplicity. For small values like integers, set might be faster.

pub fn set_silently(&mut self, new_value: E::Data)

Sets the handle's pointee to the specified value without notifying the receiver. Doing this is heavily discouraged and should only be used in special cases.

For large values where partial modification using a mutable reference would improve performance (Vec is a good example of such a type), modify_silently or modify_silently_with should be used instead.

pub fn modify_silently(&mut self) -> &mut E::Data

Returns a mutable reference to the handle's pointee. This will not notify any receiver, which is heavily discouraged and should only be used in special cases.

modify_silently_with may be used instead. For small values like integers, set_silently might be faster.

pub fn modify_silently_with<F>(&mut self, f: F) where
    F: FnMut(&mut E::Data), 

Modifies the handle's pointee using the specified closure, without notifying the receiver. Doing this is heavily discouraged and should only be used in special cases.

modify_silently may be used instead, for simplicity. For small values like integers, set_silently might be faster.

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, E, R> Debug for Handle<'a, E, R> where
    E: Entry,
    R: Receiver<E>,
    E::Data: Debug, 

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

Formats the value using the given formatter.

impl<'a, E, R> Deref for Handle<'a, E, R> where
    E: Entry,
    R: Receiver<E>,
    E::Data: Deref, 

type Target = E::Data

The resulting type after dereferencing.

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

Dereferences the value.