Struct tor_hsservice::internal_prelude::watch::Sender

pub struct Sender<T> {
    shared: SenderShared<StateExtension<T>>,
}

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

Fields

shared: SenderShared<StateExtension<T>>

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<(), Error>

Formats the value using the given formatter.

impl<T> PostageWatchSenderExt<T> for Sender<T>

fn try_maybe_send<F, E>(&mut self, update: F) -> Result<(), E>

where T: PartialEq, F: FnOnce(&T) -> Result<T, E>,

Update, by calling a fallible function, sending only if necessary

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 Sender<T>>, _cx: &mut Context<'_> ) -> Poll<Result<(), <Sender<T> as Sink<T>>::Error>>

Attempts to prepare the Sink to receive a value.

fn start_send( self: Pin<&mut Sender<T>>, item: T ) -> Result<(), <Sender<T> as Sink<T>>::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 Sender<T>>, _cx: &mut Context<'_> ) -> Poll<Result<(), <Sender<T> as Sink<T>>::Error>>

Flush any remaining output from this sink.

fn poll_close( self: Pin<&mut Sender<T>>, _cx: &mut Context<'_> ) -> Poll<Result<(), <Sender<T> as Sink<T>>::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 Sender<T>>, _cx: &mut Context<'_>, value: <Sender<T> as Sink>::Item ) -> PollSend<<Sender<T> as Sink>::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