Struct multi_producer_sink::SyncMPS

pub struct SyncMPS<S: Sink> { /* fields omitted */ }

A multi producer sink (SyncMPS). This is a cloneable handle to a single sink of type S, and each handle can be used to write to the inner sink.

An error is signaled via the Done, the sink methods themselves only return Err(()). Upon encountering an error, all handles are notified and they return Err(()). All further polling will always yield Err(None) as well.

Unless an error occured, each of the handles must invoke close before being dropped. The inner sink is closed when each of the handles has closed and emitted via the Done.

Trait Implementations

impl<S: Sink> Drop for SyncMPS<S>

Performs minimal cleanup to allow for correct closing behaviour

fn drop(&mut self)

Executes the destructor for this type.

impl<S: Sink> Clone for SyncMPS<S>

fn clone(&self) -> SyncMPS<S>

Returns a new handle to the same underlying sink.

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

Performs copy-assignment from source.

impl<S: Sink> Sink for SyncMPS<S>

type SinkItem = S::SinkItem

The type of value that the sink accepts.

type SinkError = ()

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

fn poll_ready(&mut self, cx: &mut Context) -> Poll<(), Self::SinkError>

Attempts to prepare the Sink to receive a value.

fn start_send(&mut self, item: S::SinkItem) -> Result<(), Self::SinkError>

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

fn poll_flush(&mut self, cx: &mut Context) -> Poll<(), Self::SinkError>

Flush any remaining output from this sink.

fn poll_close(&mut self, cx: &mut Context) -> Poll<(), Self::SinkError>

This only delegates to the poll_close method of the inner sink if all other active handles have already called close. Else, it simply flushes the underlying sink, but does not close it.

Calling clone after calling close leads to ambiguity whether the inner sink has actually closed yet. It's still safe, but not advisable.

impl<S: Sink> MPS<S> for SyncMPS<S>

type Done = SyncDone<S>

A future that signals when the wrapped sink is done.

fn mps(sink: S) -> (Self, Self::Done)

Create a new MPS from a sink and a Done to notify when it is done.