[−][src]Struct futures_util::sink::Fanout

pub struct Fanout<Si1: Sink, Si2: Sink> { /* fields omitted */ }

Sink that clones incoming items and forwards them to two sinks at the same time.

Backpressure from any downstream sink propagates up, which means that this sink can only process items as fast as its slowest downstream sink.

Methods

`impl<Si1: Sink, Si2: Sink> Fanout<Si1, Si2>`[src]

`pub fn into_inner(self) -> (Si1, Si2)`[src]

Consumes this combinator, returning the underlying sinks.

Note that this may discard intermediate state of this combinator, so care should be taken to avoid losing resources when this is called.

Trait Implementations

`impl<Si1: Sink + Debug, Si2: Sink + Debug> Debug for Fanout<Si1, Si2> where Si1::SinkItem: Debug, Si2::SinkItem: Debug,` [src]

`fn fmt(&self, f: &mut Formatter) -> FmtResult`[src]

`impl<Si1, Si2> Sink for Fanout<Si1, Si2> where Si1: Sink, Si1::SinkItem: Clone, Si2: Sink<SinkItem = Si1::SinkItem, SinkError = Si1::SinkError>,` [src]

`type SinkItem = Si1::SinkItem`

The type of value that the sink accepts.

`type SinkError = Si1::SinkError`

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

`fn poll_ready( self: Pin<&mut Self>, lw: &LocalWaker ) -> Poll<Result<(), Self::SinkError>>`[src]

`fn start_send( self: Pin<&mut Self>, item: Self::SinkItem ) -> Result<(), Self::SinkError>`[src]

`fn poll_flush( self: Pin<&mut Self>, lw: &LocalWaker ) -> Poll<Result<(), Self::SinkError>>`[src]

`fn poll_close( self: Pin<&mut Self>, lw: &LocalWaker ) -> Poll<Result<(), Self::SinkError>>`[src]

Auto Trait Implementations

`impl<Si1, Si2> Send for Fanout<Si1, Si2> where Si1: Send, Si2: Send,`

`impl<Si1, Si2> Sync for Fanout<Si1, Si2> where Si1: Sync, Si2: Sync,`

Blanket Implementations

`impl<T> SinkExt for T where T: Sink + ?Sized,` [src]

`fn with<U, Fut, F, E>(self, f: F) -> With<Self, U, Fut, F> where F: FnMut(U) -> Fut, Fut: Future<Output = Result<Self::SinkItem, E>>, E: From<Self::SinkError>, Self: Sized,` [src]

Composes a function in front of the sink. Read more

`fn with_flat_map<U, St, F>(self, f: F) -> WithFlatMap<Self, U, St, F> where F: FnMut(U) -> St, St: Stream<Item = Result<Self::SinkItem, Self::SinkError>>, Self: Sized,` [src]

Composes a function in front of the sink. Read more

`fn sink_map_err<E, F>(self, f: F) -> SinkMapErr<Self, F> where F: FnOnce(Self::SinkError) -> E, Self: Sized,` [src]

Transforms the error returned by the sink.

`fn sink_err_into<E>(self) -> SinkErrInto<Self, E> where Self: Sized, Self::SinkError: Into<E>,` [src]

Map this sink's error to a different error type using the Into trait. Read more

`fn buffer(self, capacity: usize) -> Buffer<Self> where Self: Sized,` [src]

Adds a fixed-size buffer to the current sink. Read more

`fn close(&mut self) -> Close<Self> where Self: Unpin,` [src]

Close the sink.

`fn fanout<Si>(self, other: Si) -> Fanout<Self, Si> where Self: Sized, Self::SinkItem: Clone, Si: Sink<SinkItem = Self::SinkItem, SinkError = Self::SinkError>,` [src]

Fanout items to multiple sinks. Read more

`fn flush(&mut self) -> Flush<Self> where Self: Unpin,` [src]

Flush the sync, processing all pending items. Read more

`fn send(&mut self, item: Self::SinkItem) -> Send<Self> where Self: Unpin,` [src]

A future that completes after the given item has been fully processed into the sink, including flushing. Read more

`fn send_all<'a, St>(&'a mut self, stream: &'a mut St) -> SendAll<'a, Self, St> where St: Stream<Item = Self::SinkItem> + Unpin, Self: Unpin,` [src]

A future that completes after the given stream has been fully processed into the sink, including flushing. Read more

ⓘImportant traits for Either<L, R>
Important traits for Either<L, R>
`impl<L, R> Iterator for Either<L, R> where L: Iterator, R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;`
`fn left_sink<Si2>(self) -> Either<Self, Si2> where Si2: Sink<SinkItem = Self::SinkItem, SinkError = Self::SinkError>, Self: Sized,` [src]

Wrap this sink in an Either sink, making it the left-hand variant of that Either. Read more

ⓘImportant traits for Either<L, R>
Important traits for Either<L, R>
`impl<L, R> Iterator for Either<L, R> where L: Iterator, R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;`
`fn right_sink<Si1>(self) -> Either<Si1, Self> where Si1: Sink<SinkItem = Self::SinkItem, SinkError = Self::SinkError>, Self: Sized,` [src]

Wrap this stream in an Either stream, making it the right-hand variant of that Either. Read more

ⓘImportant traits for Compat<R>
Important traits for Compat<R>
`impl<R: AsyncRead03> Read for Compat<R>impl<W: AsyncWrite03> Write for Compat<W>`
`fn compat(self) -> Compat<Self> where Self: Sized + Unpin,` [src]

Wraps a Sink into a sink compatible with libraries using futures 0.1 Sink. Requires the compat feature to be enabled. Read more

`impl<T> From for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<T, U> TryFrom for T where T: From,` [src]

`type Error = !`

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T> Borrow for T where T: ?Sized,` [src]

ⓘImportant traits for &'_ mut I
Important traits for &'_ mut I
`impl<'_, I> Iterator for &'_ mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut for T where T: ?Sized,` [src]

ⓘImportant traits for &'_ mut I
Important traits for &'_ mut I
`impl<'_, I> Iterator for &'_ mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

[−][src]Struct futures_util::sink::Fanout

Methods

impl<Si1: Sink, Si2: Sink> Fanout<Si1, Si2>[src]

pub fn into_inner(self) -> (Si1, Si2)[src]

Trait Implementations

impl<Si1: Sink + Debug, Si2: Sink + Debug> Debug for Fanout<Si1, Si2> where Si1::SinkItem: Debug, Si2::SinkItem: Debug, [src]

fn fmt(&self, f: &mut Formatter) -> FmtResult[src]

impl<Si1, Si2> Sink for Fanout<Si1, Si2> where Si1: Sink, Si1::SinkItem: Clone, Si2: Sink<SinkItem = Si1::SinkItem, SinkError = Si1::SinkError>, [src]

type SinkItem = Si1::SinkItem

type SinkError = Si1::SinkError

fn poll_ready( self: Pin<&mut Self>, lw: &LocalWaker) -> Poll<Result<(), Self::SinkError>>[src]

fn start_send( self: Pin<&mut Self>, item: Self::SinkItem) -> Result<(), Self::SinkError>[src]

fn poll_flush( self: Pin<&mut Self>, lw: &LocalWaker) -> Poll<Result<(), Self::SinkError>>[src]

fn poll_close( self: Pin<&mut Self>, lw: &LocalWaker) -> Poll<Result<(), Self::SinkError>>[src]

Auto Trait Implementations

impl<Si1, Si2> Send for Fanout<Si1, Si2> where Si1: Send, Si2: Send,

impl<Si1, Si2> Sync for Fanout<Si1, Si2> where Si1: Sync, Si2: Sync,

Blanket Implementations

impl<T> SinkExt for T where T: Sink + ?Sized, [src]

fn with<U, Fut, F, E>(self, f: F) -> With<Self, U, Fut, F> where F: FnMut(U) -> Fut, Fut: Future<Output = Result<Self::SinkItem, E>>, E: From<Self::SinkError>, Self: Sized, [src]

fn with_flat_map<U, St, F>(self, f: F) -> WithFlatMap<Self, U, St, F> where F: FnMut(U) -> St, St: Stream<Item = Result<Self::SinkItem, Self::SinkError>>, Self: Sized, [src]

fn sink_map_err<E, F>(self, f: F) -> SinkMapErr<Self, F> where F: FnOnce(Self::SinkError) -> E, Self: Sized, [src]

fn sink_err_into<E>(self) -> SinkErrInto<Self, E> where Self: Sized, Self::SinkError: Into<E>, [src]

fn buffer(self, capacity: usize) -> Buffer<Self> where Self: Sized, [src]

fn close(&mut self) -> Close<Self> where Self: Unpin, [src]

fn fanout<Si>(self, other: Si) -> Fanout<Self, Si> where Self: Sized, Self::SinkItem: Clone, Si: Sink<SinkItem = Self::SinkItem, SinkError = Self::SinkError>, [src]

fn flush(&mut self) -> Flush<Self> where Self: Unpin, [src]

fn send(&mut self, item: Self::SinkItem) -> Send<Self> where Self: Unpin, [src]

fn send_all<'a, St>(&'a mut self, stream: &'a mut St) -> SendAll<'a, Self, St> where St: Stream<Item = Self::SinkItem> + Unpin, Self: Unpin, [src]

Important traits for Either<L, R>

Important traits for Either<L, R>

ⓘImportant traits for Compat<R>Important traits for Compat<R>impl<R: AsyncRead03> Read for Compat<R>impl<W: AsyncWrite03> Write for Compat<W>fn compat(self) -> Compat<Self> where Self: Sized + Unpin, [src]

Important traits for Compat<R>

impl<T> From for T[src]

fn from(t: T) -> T[src]

impl<T, U> Into for T where U: From<T>, [src]

fn into(self) -> U[src]

impl<T, U> TryFrom for T where T: From<U>, [src]

type Error = !

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]

impl<T> Borrow for T where T: ?Sized, [src]

ⓘImportant traits for &'_ mut IImportant traits for &'_ mut Iimpl<'_, I> Iterator for &'_ mut I where I: Iterator + ?Sized, type Item = <I as Iterator>::Item;fn borrow(&self) -> &T[src]

Important traits for &'_ mut I

impl<T> BorrowMut for T where T: ?Sized, [src]

ⓘImportant traits for &'_ mut IImportant traits for &'_ mut Iimpl<'_, I> Iterator for &'_ mut I where I: Iterator + ?Sized, type Item = <I as Iterator>::Item;fn borrow_mut(&mut self) -> &mut T[src]