Struct Sender 

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

The sender half of a watch channel. The stored value can be updated with the postage::Sink trait.

Implementations

impl<T> Sender<T>

pub fn borrow_mut<'s>(&'s mut self) -> RefMut<'s, T>

Mutably borrows the contained value, blocking the channel while the borrow is held.

After the borrow is released, receivers will be notified of a new value.

pub fn subscribe(&mut self) -> Receiver<T>

Creates a new Receiver that listens to this channel.

pub fn borrow<'s>(&'s mut self) -> Ref<'s, T>

Immutably borrows the contained value, blocking the channel while the borrow is held.

Trait Implementations

impl<T> Debug for Sender<T>

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

Formats the value using the given formatter.

impl<T> Sink<T> for Sender<T>

type Error = SendError<T>

The type of value produced by the sink when an error occurs.

fn poll_ready( self: Pin<&mut Self>, _cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, item: T) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_flush( self: Pin<&mut Self>, _cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

fn poll_close( self: Pin<&mut Self>, _cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.

impl<T> Sink for Sender<T>

type Item = T

fn poll_send( self: Pin<&mut Self>, _cx: &mut Context<'_>, value: Self::Item, ) -> PollSend<Self::Item>

Attempts to accept the message, without blocking.

fn send(&mut self, value: Self::Item) -> SendFuture<'_, Self>

Attempts to send a message into the sink.

fn try_send( &mut self, value: Self::Item, ) -> Result<(), TrySendError<Self::Item>>

where Self: Unpin,

Attempts to send a message over the sink, without blocking.

fn after<Before>(self, before: Before) -> ChainSink<Before, Self>

where Before: Sink<Item = Self::Item>, Self: Sized,

Chains two sink implementations. Messages will be transmitted to the argument until it rejects a message. Then messages will be transmitted to self.

fn filter<Filter>(self, filter: Filter) -> FilterSink<Filter, Self>

where Filter: FnMut(&Self::Item) -> bool, Self: Sized,

Filters messages, forwarding them to the sink if the filter returns true

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 8 bytes