Struct Map

pub struct Map<W: Watcher, T: Clone + Eq> { /* private fields */ }

Wraps a Watcher to allow observing a derived value.

See Watcher::map.

Trait Implementations

impl<W: Clone + Watcher, T: Clone + Clone + Eq> Clone for Map<W, T>

where W::Value: Clone,

fn clone(&self) -> Map<W, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<W, T> Debug for Map<W, T>

where W: Debug + Watcher, T: Debug + Clone + Eq,

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

Formats the value using the given formatter.

impl<W: Watcher, T: Clone + Eq> Watcher for Map<W, T>

type Value = T

The type of value that can change.

fn get(&mut self) -> Self::Value

Returns the current state of the underlying value.

fn is_connected(&self) -> bool

Whether this watcher is still connected to all of its underlying Watchables.

fn poll_updated( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<Self::Value, Disconnected>>

Polls for the next value, or returns Disconnected if one of the underlying Watchables has been dropped.

fn updated(&mut self) -> NextFut<'_, Self>

Returns a future completing with Ok(value) once a new value is set, or with Err(Disconnected) if the connected Watchable was dropped.

fn initialized<T, W>(&mut self) -> InitializedFut<'_, T, W, Self>

where W: Nullable<T>, Self: Watcher<Value = W>,

Returns a future completing once the value is set to Some value.

fn stream(self) -> Stream<Self>

where Self: Unpin,

Returns a stream which will yield the most recent values as items.

fn stream_updates_only(self) -> Stream<Self>

where Self: Unpin,

Returns a stream which will yield the most recent values as items, starting from the next unobserved future value.

fn map<T: Clone + Eq>( self, map: impl Fn(Self::Value) -> T + Send + Sync + 'static, ) -> Map<Self, T>

Maps this watcher with a function that transforms the observed values.

fn filter<T>( self, filter: impl Fn(&T) -> bool + Send + Sync + 'static, ) -> Filter<Self, T>

where T: Clone + Eq, Self: Watcher<Value = T>,

fn or<W: Watcher>(self, other: W) -> (Self, W)

Returns a watcher that updates every time this or the other watcher updates, and yields both watcher’s items together when that happens.