Struct futures01::sink::With [−][src]
Sink for the Sink::with
combinator, chaining a computation to run prior
to pushing a value into the underlying sink.
Implementations
impl<S, U, F, Fut> With<S, U, F, Fut> where
F: FnMut(U) -> Fut,
S: Sink,
Fut: IntoFuture<Item = <S as Sink>::SinkItem>,
<Fut as IntoFuture>::Error: From<<S as Sink>::SinkError>,
[src]
F: FnMut(U) -> Fut,
S: Sink,
Fut: IntoFuture<Item = <S as Sink>::SinkItem>,
<Fut as IntoFuture>::Error: From<<S as Sink>::SinkError>,
pub fn get_ref(&self) -> &S
[src]
Get a shared reference to the inner sink.
pub fn get_mut(&mut self) -> &mut S
[src]
Get a mutable reference to the inner sink.
pub fn into_inner(self) -> S
[src]
Consumes this combinator, returning the underlying sink.
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<S, U, F, Fut> Clone for With<S, U, F, Fut> where
F: Clone + FnMut(U) -> Fut,
U: Clone,
S: Clone + Sink,
Fut: Clone + IntoFuture,
<Fut as IntoFuture>::Future: Clone,
<S as Sink>::SinkItem: Clone,
[src]
F: Clone + FnMut(U) -> Fut,
U: Clone,
S: Clone + Sink,
Fut: Clone + IntoFuture,
<Fut as IntoFuture>::Future: Clone,
<S as Sink>::SinkItem: Clone,
impl<S, U, F, Fut> Debug for With<S, U, F, Fut> where
F: Debug + FnMut(U) -> Fut,
U: Debug,
S: Debug + Sink,
Fut: Debug + IntoFuture,
<Fut as IntoFuture>::Future: Debug,
<S as Sink>::SinkItem: Debug,
[src]
F: Debug + FnMut(U) -> Fut,
U: Debug,
S: Debug + Sink,
Fut: Debug + IntoFuture,
<Fut as IntoFuture>::Future: Debug,
<S as Sink>::SinkItem: Debug,
impl<S, U, F, Fut> Sink for With<S, U, F, Fut> where
F: FnMut(U) -> Fut,
S: Sink,
Fut: IntoFuture<Item = <S as Sink>::SinkItem>,
<Fut as IntoFuture>::Error: From<<S as Sink>::SinkError>,
[src]
F: FnMut(U) -> Fut,
S: Sink,
Fut: IntoFuture<Item = <S as Sink>::SinkItem>,
<Fut as IntoFuture>::Error: From<<S as Sink>::SinkError>,
type SinkItem = U
The type of value that the sink accepts.
type SinkError = <Fut as IntoFuture>::Error
The type of value produced by the sink when an error occurs.
pub fn start_send(
&mut self,
item: <With<S, U, F, Fut> as Sink>::SinkItem
) -> Result<AsyncSink<<With<S, U, F, Fut> as Sink>::SinkItem>, <Fut as IntoFuture>::Error>
[src]
&mut self,
item: <With<S, U, F, Fut> as Sink>::SinkItem
) -> Result<AsyncSink<<With<S, U, F, Fut> as Sink>::SinkItem>, <Fut as IntoFuture>::Error>
pub fn poll_complete(&mut self) -> Result<Async<()>, <Fut as IntoFuture>::Error>
[src]
pub fn close(&mut self) -> Result<Async<()>, <Fut as IntoFuture>::Error>
[src]
pub fn wait(self) -> Wait<Self>
[src]
pub fn with<U, F, Fut>(self, f: F) -> With<Self, U, F, Fut> where
F: FnMut(U) -> Fut,
Fut: IntoFuture<Item = Self::SinkItem>,
<Fut as IntoFuture>::Error: From<Self::SinkError>,
[src]
F: FnMut(U) -> Fut,
Fut: IntoFuture<Item = Self::SinkItem>,
<Fut as IntoFuture>::Error: From<Self::SinkError>,
pub 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>,
[src]
F: FnMut(U) -> St,
St: Stream<Item = Self::SinkItem, Error = Self::SinkError>,
pub fn sink_map_err<F, E>(self, f: F) -> SinkMapErr<Self, F> where
F: FnOnce(Self::SinkError) -> E,
[src]
F: FnOnce(Self::SinkError) -> E,
pub fn sink_from_err<E>(self) -> SinkFromErr<Self, E> where
E: From<Self::SinkError>,
[src]
E: From<Self::SinkError>,
pub fn buffer(self, amt: usize) -> Buffer<Self>
[src]
pub fn fanout<S>(self, other: S) -> Fanout<Self, S> where
S: Sink<SinkItem = Self::SinkItem, SinkError = Self::SinkError>,
Self::SinkItem: Clone,
[src]
S: Sink<SinkItem = Self::SinkItem, SinkError = Self::SinkError>,
Self::SinkItem: Clone,
pub fn flush(self) -> Flush<Self>
[src]
pub fn send(self, item: Self::SinkItem) -> Send<Self>
[src]
pub fn send_all<S>(self, stream: S) -> SendAll<Self, S> where
S: Stream<Item = Self::SinkItem>,
Self::SinkError: From<<S as Stream>::Error>,
[src]
S: Stream<Item = Self::SinkItem>,
Self::SinkError: From<<S as Stream>::Error>,
impl<S, U, F, Fut> Stream for With<S, U, F, Fut> where
F: FnMut(U) -> Fut,
S: Stream + Sink,
Fut: IntoFuture,
[src]
F: FnMut(U) -> Fut,
S: Stream + Sink,
Fut: IntoFuture,
type Item = <S as Stream>::Item
The type of item this stream will yield on success.
type Error = <S as Stream>::Error
The type of error this stream may generate.
pub fn poll(
&mut self
) -> Result<Async<Option<<S as Stream>::Item>>, <S as Stream>::Error>
[src]
&mut self
) -> Result<Async<Option<<S as Stream>::Item>>, <S as Stream>::Error>
pub fn wait(self) -> Wait<Self>ⓘ
[src]
pub fn into_future(self) -> StreamFuture<Self>
[src]
pub fn map<U, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> U,
[src]
F: FnMut(Self::Item) -> U,
pub fn map_err<U, F>(self, f: F) -> MapErr<Self, F> where
F: FnMut(Self::Error) -> U,
[src]
F: FnMut(Self::Error) -> U,
pub fn filter<F>(self, f: F) -> Filter<Self, F> where
F: FnMut(&Self::Item) -> bool,
[src]
F: FnMut(&Self::Item) -> bool,
pub fn filter_map<F, B>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>,
[src]
F: FnMut(Self::Item) -> Option<B>,
pub fn then<F, U>(self, f: F) -> Then<Self, F, U> where
F: FnMut(Result<Self::Item, Self::Error>) -> U,
U: IntoFuture,
[src]
F: FnMut(Result<Self::Item, Self::Error>) -> U,
U: IntoFuture,
pub fn and_then<F, U>(self, f: F) -> AndThen<Self, F, U> where
F: FnMut(Self::Item) -> U,
U: IntoFuture<Error = Self::Error>,
[src]
F: FnMut(Self::Item) -> U,
U: IntoFuture<Error = Self::Error>,
pub fn or_else<F, U>(self, f: F) -> OrElse<Self, F, U> where
F: FnMut(Self::Error) -> U,
U: IntoFuture<Item = Self::Item>,
[src]
F: FnMut(Self::Error) -> U,
U: IntoFuture<Item = Self::Item>,
pub fn collect(self) -> Collect<Self>
[src]
pub fn concat2(self) -> Concat2<Self> where
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
[src]
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
pub fn concat(self) -> Concat<Self> where
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
[src]
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
pub fn fold<F, T, Fut>(self, init: T, f: F) -> Fold<Self, F, Fut, T> where
F: FnMut(T, Self::Item) -> Fut,
Fut: IntoFuture<Item = T>,
Self::Error: From<<Fut as IntoFuture>::Error>,
[src]
F: FnMut(T, Self::Item) -> Fut,
Fut: IntoFuture<Item = T>,
Self::Error: From<<Fut as IntoFuture>::Error>,
pub fn flatten(self) -> Flatten<Self> where
Self::Item: Stream,
<Self::Item as Stream>::Error: From<Self::Error>,
[src]
Self::Item: Stream,
<Self::Item as Stream>::Error: From<Self::Error>,
pub fn skip_while<P, R>(self, pred: P) -> SkipWhile<Self, P, R> where
P: FnMut(&Self::Item) -> R,
R: IntoFuture<Item = bool, Error = Self::Error>,
[src]
P: FnMut(&Self::Item) -> R,
R: IntoFuture<Item = bool, Error = Self::Error>,
pub fn take_while<P, R>(self, pred: P) -> TakeWhile<Self, P, R> where
P: FnMut(&Self::Item) -> R,
R: IntoFuture<Item = bool, Error = Self::Error>,
[src]
P: FnMut(&Self::Item) -> R,
R: IntoFuture<Item = bool, Error = Self::Error>,
pub fn for_each<F, U>(self, f: F) -> ForEach<Self, F, U> where
F: FnMut(Self::Item) -> U,
U: IntoFuture<Item = (), Error = Self::Error>,
[src]
F: FnMut(Self::Item) -> U,
U: IntoFuture<Item = (), Error = Self::Error>,
pub fn from_err<E>(self) -> FromErr<Self, E> where
E: From<Self::Error>,
[src]
E: From<Self::Error>,
pub fn take(self, amt: u64) -> Take<Self>
[src]
pub fn skip(self, amt: u64) -> Skip<Self>
[src]
pub fn fuse(self) -> Fuse<Self>
[src]
pub fn by_ref(&mut self) -> &mut Self
[src]
pub fn catch_unwind(self) -> CatchUnwind<Self> where
Self: UnwindSafe,
[src]
Self: UnwindSafe,
pub fn buffered(self, amt: usize) -> Buffered<Self> where
Self::Item: IntoFuture,
<Self::Item as IntoFuture>::Error == Self::Error,
[src]
Self::Item: IntoFuture,
<Self::Item as IntoFuture>::Error == Self::Error,
pub fn buffer_unordered(self, amt: usize) -> BufferUnordered<Self> where
Self::Item: IntoFuture,
<Self::Item as IntoFuture>::Error == Self::Error,
[src]
Self::Item: IntoFuture,
<Self::Item as IntoFuture>::Error == Self::Error,
pub fn merge<S>(self, other: S) -> Merge<Self, S> where
S: Stream<Error = Self::Error>,
[src]
S: Stream<Error = Self::Error>,
pub fn zip<S>(self, other: S) -> Zip<Self, S> where
S: Stream<Error = Self::Error>,
[src]
S: Stream<Error = Self::Error>,
pub fn chain<S>(self, other: S) -> Chain<Self, S> where
S: Stream<Item = Self::Item, Error = Self::Error>,
[src]
S: Stream<Item = Self::Item, Error = Self::Error>,
pub fn peekable(self) -> Peekable<Self>
[src]
pub fn chunks(self, capacity: usize) -> Chunks<Self>
[src]
pub fn select<S>(self, other: S) -> Select<Self, S> where
S: Stream<Item = Self::Item, Error = Self::Error>,
[src]
S: Stream<Item = Self::Item, Error = Self::Error>,
pub fn forward<S>(self, sink: S) -> Forward<Self, S> where
S: Sink<SinkItem = Self::Item>,
Self::Error: From<<S as Sink>::SinkError>,
[src]
S: Sink<SinkItem = Self::Item>,
Self::Error: From<<S as Sink>::SinkError>,
pub fn split(self) -> (SplitSink<Self>, SplitStream<Self>) where
Self: Sink,
[src]
Self: Sink,
pub fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
[src]
F: FnMut(&Self::Item),
pub fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where
F: FnMut(&Self::Error),
[src]
F: FnMut(&Self::Error),
Auto Trait Implementations
impl<S, U, F, Fut> RefUnwindSafe for With<S, U, F, Fut> where
F: RefUnwindSafe,
S: RefUnwindSafe,
<Fut as IntoFuture>::Future: RefUnwindSafe,
<S as Sink>::SinkItem: RefUnwindSafe,
F: RefUnwindSafe,
S: RefUnwindSafe,
<Fut as IntoFuture>::Future: RefUnwindSafe,
<S as Sink>::SinkItem: RefUnwindSafe,
impl<S, U, F, Fut> Send for With<S, U, F, Fut> where
F: Send,
S: Send,
<Fut as IntoFuture>::Future: Send,
<S as Sink>::SinkItem: Send,
F: Send,
S: Send,
<Fut as IntoFuture>::Future: Send,
<S as Sink>::SinkItem: Send,
impl<S, U, F, Fut> Sync for With<S, U, F, Fut> where
F: Sync,
S: Sync,
<Fut as IntoFuture>::Future: Sync,
<S as Sink>::SinkItem: Sync,
F: Sync,
S: Sync,
<Fut as IntoFuture>::Future: Sync,
<S as Sink>::SinkItem: Sync,
impl<S, U, F, Fut> Unpin for With<S, U, F, Fut> where
F: Unpin,
S: Unpin,
<Fut as IntoFuture>::Future: Unpin,
<S as Sink>::SinkItem: Unpin,
F: Unpin,
S: Unpin,
<Fut as IntoFuture>::Future: Unpin,
<S as Sink>::SinkItem: Unpin,
impl<S, U, F, Fut> UnwindSafe for With<S, U, F, Fut> where
F: UnwindSafe,
S: UnwindSafe,
<Fut as IntoFuture>::Future: UnwindSafe,
<S as Sink>::SinkItem: UnwindSafe,
F: UnwindSafe,
S: UnwindSafe,
<Fut as IntoFuture>::Future: UnwindSafe,
<S as Sink>::SinkItem: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,