Struct fuchsia_inspect_contrib::inspectable::Inspectable

pub struct Inspectable<V, W>
where
    W: Watch<V>,
{ /* private fields */ }

Generic wrapper for exporting variables via Inspect. Mutations to the wrapped value occur through an InspectableGuard, which notifies the watcher when Dropped, transparently keeping the Inspect state up-to-date.

How the value is exported is determined by the Watch implementation, see e.g. InspectableDebugString.

Not correct for Vs with interior mutability, because Inspectable Derefs to V, mutations to which will bypass the watcher.

Implementations

impl<V, W> Inspectable<V, W>

where W: Watch<V>,

pub fn new(value: V, node: &Node, name: impl Into<StringReference>) -> Self

Creates an Inspectable wrapping value. Exports value via Inspect.

pub fn get_mut(&mut self) -> InspectableGuard<'_, V, W>

Returns a guard that DerefMuts to the wrapped value. The watcher will receive the updated value when the guard is Dropped.

Trait Implementations

impl<V, W> Borrow<V> for Inspectable<V, W>

where W: Watch<V>,

fn borrow(&self) -> &V

Immutably borrows from an owned value.

impl<V, W> Debug for Inspectable<V, W>

where W: Watch<V>, V: Debug,

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

Formats the value using the given formatter.

impl<V, W> Deref for Inspectable<V, W>

where W: Watch<V>,

type Target = V

The resulting type after dereferencing.

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

Dereferences the value.

impl<V, W> Hash for Inspectable<V, W>

where W: Watch<V>, V: Hash,

fn hash<__HVW>(&self, __state: &mut __HVW)

where __HVW: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<V, W> PartialEq for Inspectable<V, W>

where W: Watch<V>, V: PartialEq,

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V, W> Eq for Inspectable<V, W>

where W: Watch<V>, V: Eq,