# Struct futures::sink::Fanout [−] [src]

    pub struct Fanout<A: Sink, B: 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<A: Sink, B: Sink> Fanout<A, B>`
[src]

#### `pub fn into_inner(self) -> (A, B)`
[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<A: Sink + Debug, B: Sink + Debug> Debug for Fanout<A, B> where
A::SinkItem: Debug,
B::SinkItem: Debug,`
[src]

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

Formats the value using the given formatter. Read more

### `impl<A, B> Sink for Fanout<A, B> where
A: Sink,
A::SinkItem: Clone,
B: Sink<SinkItem = A::SinkItem, SinkError = A::SinkError>,`
[src]

#### `type SinkItem = A::SinkItem`

The type of value that the sink accepts.

#### `type SinkError = A::SinkError`

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

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

Begin the process of sending a value to the sink. Read more

#### `fn poll_complete(&mut self) -> Poll<(), Self::SinkError>`
[src]

Flush all output from this sink, if necessary. Read more

#### `fn close(&mut self) -> Poll<(), Self::SinkError>`
[src]

A method to indicate that no more values will ever be pushed into this sink. Read more

#### `fn wait(self) -> Wait<Self> where
Self: Sized,`
[src]

Creates a new object which will produce a synchronous sink. Read more

#### `fn with<U, F, Fut>(self, f: F) -> With<Self, U, F, Fut> where
F: FnMut(U) -> Fut,
Fut: IntoFuture<Item = Self::SinkItem>,
Fut::Error: From<Self::SinkError>,
Self: Sized,`
[src]

Composes a function in front of the sink. Read more

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

Composes a function in front of the sink. Read more

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

Transforms the error returned by the sink.

#### `fn sink_from_err<E: From<Self::SinkError>>(self) -> SinkFromErr<Self, E> where
Self: Sized,`
[src]

Map this sink's error to any error implementing `From` for this sink's `Error`, returning a new sink. Read more

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

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

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

Fanout items to multiple sinks. Read more

#### `fn flush(self) -> Flush<Self> where
Self: Sized,`
[src]

A future that completes when the sink has finished processing all pending requests. Read more

#### `fn send(self, item: Self::SinkItem) -> Send<Self> where
Self: Sized,`
[src]

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

#### `fn send_all<S>(self, stream: S) -> SendAll<Self, S> where
S: Stream<Item = Self::SinkItem>,
Self::SinkError: From<S::Error>,
Self: Sized,`
[src]

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

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)