Struct Notify

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

A lightweight wrapper that guarantees an event will be generated every time the inner value is accessed mutably, even if the value doesn’t change.

This is useful for types like a play head where periodically writing the same value carries useful information.

Notify implements core::ops::Deref and core::ops::DerefMut for the inner T.

Implementations

impl<T> Notify<T>

pub fn new(value: T) -> Self

Construct a new Notify.

If two instances of Notify are constructed separately, a call to Diff::diff will produce an event, even if the value is the same.

// Diffing `a` and `b` will produce an event
let a = Notify::new(1);
let b = Notify::new(1);

// whereas `b` and `c` will not.
let c = b.clone();

pub fn id(&self) -> u64

Get this instance’s unique ID.

After each mutable dereference, this ID will be replaced with a new, unique value. For all practical purposes, the ID can be considered unique among all Notify instances.

Notify IDs are guaranteed to never be 0, so it can be used as a sentinel value.

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

Get mutable access to the inner value without updating the ID.

pub fn notify(&mut self)

Manually update the internal ID without modifying the internals.

Trait Implementations

impl<T> AsMut<T> for Notify<T>

fn as_mut(&mut self) -> &mut T

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T> AsRef<T> for Notify<T>

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone> Clone for Notify<T>

fn clone(&self) -> Notify<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for Notify<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Notify<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Deref for Notify<T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> DerefMut for Notify<T>

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

Mutably dereferences the value.

impl<T: Clone + Send + Sync + 'static> Diff for Notify<T>

fn diff<E: EventQueue>( &self, baseline: &Self, path: PathBuilder, event_queue: &mut E, )

Compare self to baseline and generate events to resolve any differences.

impl<T: Clone + Send + Sync + 'static> Patch for Notify<T>

type Patch = Notify<T>

A type’s patch.

fn patch(data: &ParamData, _: &[u32]) -> Result<Self::Patch, PatchError>

Construct a patch from a parameter event.

fn apply(&mut self, patch: Self::Patch)

Apply a patch.

fn patch_event(event: &NodeEventType) -> Option<Self::Patch>

Construct a patch from a node event.