[−][src]Struct futures::sink::SinkMapErr
Sink for the sink_map_err method.
Implementations
impl<Si, F> SinkMapErr<Si, F>[src]
pub fn get_ref(&self) -> &Siⓘ[src]
Acquires a reference to the underlying sink or stream that this combinator is pulling from.
pub fn get_mut(&mut self) -> &mut Siⓘ[src]
Acquires a mutable reference to the underlying sink or stream that this combinator is pulling from.
Note that care must be taken to avoid tampering with the state of the sink or stream which may otherwise confuse this combinator.
pub fn get_pin_mut(self: Pin<&mut SinkMapErr<Si, F>>) -> Pin<&mut Si>ⓘ[src]
Acquires a pinned mutable reference to the underlying sink or stream that this combinator is pulling from.
Note that care must be taken to avoid tampering with the state of the sink or stream which may otherwise confuse this combinator.
pub fn into_inner(self) -> Si[src]
Consumes this combinator, returning the underlying sink or stream.
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<Si, F> Clone for SinkMapErr<Si, F> where
F: Clone,
Si: Clone, [src]
F: Clone,
Si: Clone,
fn clone(&self) -> SinkMapErr<Si, F>[src]
fn clone_from(&mut self, source: &Self)1.0.0[src]
impl<Si, F> Debug for SinkMapErr<Si, F> where
F: Debug,
Si: Debug, [src]
F: Debug,
Si: Debug,
impl<S, F> FusedStream for SinkMapErr<S, F> where
S: FusedStream, [src]
S: FusedStream,
fn is_terminated(&self) -> bool[src]
impl<Si, F, E, Item> Sink<Item> for SinkMapErr<Si, F> where
F: FnOnce(<Si as Sink<Item>>::Error) -> E,
Si: Sink<Item>, [src]
F: FnOnce(<Si as Sink<Item>>::Error) -> E,
Si: Sink<Item>,
type Error = E
The type of value produced by the sink when an error occurs.
fn poll_ready(
self: Pin<&mut SinkMapErr<Si, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <SinkMapErr<Si, F> as Sink<Item>>::Error>>[src]
self: Pin<&mut SinkMapErr<Si, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <SinkMapErr<Si, F> as Sink<Item>>::Error>>
fn start_send(
self: Pin<&mut SinkMapErr<Si, F>>,
item: Item
) -> Result<(), <SinkMapErr<Si, F> as Sink<Item>>::Error>[src]
self: Pin<&mut SinkMapErr<Si, F>>,
item: Item
) -> Result<(), <SinkMapErr<Si, F> as Sink<Item>>::Error>
fn poll_flush(
self: Pin<&mut SinkMapErr<Si, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <SinkMapErr<Si, F> as Sink<Item>>::Error>>[src]
self: Pin<&mut SinkMapErr<Si, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <SinkMapErr<Si, F> as Sink<Item>>::Error>>
fn poll_close(
self: Pin<&mut SinkMapErr<Si, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <SinkMapErr<Si, F> as Sink<Item>>::Error>>[src]
self: Pin<&mut SinkMapErr<Si, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <SinkMapErr<Si, F> as Sink<Item>>::Error>>
impl<S, F> Stream for SinkMapErr<S, F> where
S: Stream, [src]
S: Stream,
type Item = <S as Stream>::Item
Values yielded by the stream.
fn poll_next(
self: Pin<&mut SinkMapErr<S, F>>,
cx: &mut Context<'_>
) -> Poll<Option<<SinkMapErr<S, F> as Stream>::Item>>[src]
self: Pin<&mut SinkMapErr<S, F>>,
cx: &mut Context<'_>
) -> Poll<Option<<SinkMapErr<S, F> as Stream>::Item>>
fn size_hint(&self) -> (usize, Option<usize>)[src]
impl<'pin, Si, F> Unpin for SinkMapErr<Si, F> where
__SinkMapErr<'pin, Si, F>: Unpin, [src]
__SinkMapErr<'pin, Si, F>: Unpin,
impl<Si, F> UnsafeUnpin for SinkMapErr<Si, F>[src]
Auto Trait Implementations
impl<Si, F> RefUnwindSafe for SinkMapErr<Si, F> where
F: RefUnwindSafe,
Si: RefUnwindSafe,
F: RefUnwindSafe,
Si: RefUnwindSafe,
impl<Si, F> Send for SinkMapErr<Si, F> where
F: Send,
Si: Send,
F: Send,
Si: Send,
impl<Si, F> Sync for SinkMapErr<Si, F> where
F: Sync,
Si: Sync,
F: Sync,
Si: Sync,
impl<Si, F> UnwindSafe for SinkMapErr<Si, F> where
F: UnwindSafe,
Si: UnwindSafe,
F: UnwindSafe,
Si: 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,
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, Item> SinkExt<Item> for T where
T: Sink<Item> + ?Sized, [src]
T: Sink<Item> + ?Sized,
fn with<U, Fut, F, E>(self, f: F) -> With<Self, Item, U, Fut, F> where
E: From<Self::Error>,
F: FnMut(U) -> Fut,
Fut: Future<Output = Result<Item, E>>, [src]
E: From<Self::Error>,
F: FnMut(U) -> Fut,
Fut: Future<Output = Result<Item, E>>,
fn with_flat_map<U, St, F>(self, f: F) -> WithFlatMap<Self, Item, U, St, F> where
F: FnMut(U) -> St,
St: Stream<Item = Result<Item, Self::Error>>, [src]
F: FnMut(U) -> St,
St: Stream<Item = Result<Item, Self::Error>>,
fn sink_map_err<E, F>(self, f: F) -> SinkMapErr<Self, F> where
F: FnOnce(Self::Error) -> E, [src]
F: FnOnce(Self::Error) -> E,
fn sink_err_into<E>(self) -> SinkErrInto<Self, Item, E> where
Self::Error: Into<E>, [src]
Self::Error: Into<E>,
fn buffer(self, capacity: usize) -> Buffer<Self, Item>[src]
fn close(&mut self) -> Close<'_, Self, Item>ⓘ where
Self: Unpin, [src]
Self: Unpin,
fn fanout<Si>(self, other: Si) -> Fanout<Self, Si> where
Item: Clone,
Si: Sink<Item, Error = Self::Error>, [src]
Item: Clone,
Si: Sink<Item, Error = Self::Error>,
fn flush(&mut self) -> Flush<'_, Self, Item>ⓘ where
Self: Unpin, [src]
Self: Unpin,
fn send(&mut self, item: Item) -> Send<'_, Self, Item>ⓘ where
Self: Unpin, [src]
Self: Unpin,
fn send_all<St>(&'a mut self, stream: &'a mut St) -> SendAll<'a, Self, St>ⓘ where
Self: Unpin,
St: TryStream<Ok = Item, Error = Self::Error> + Stream + Unpin + ?Sized, [src]
Self: Unpin,
St: TryStream<Ok = Item, Error = Self::Error> + Stream + Unpin + ?Sized,
fn left_sink<Si2>(self) -> Either<Self, Si2>ⓘ where
Si2: Sink<Item, Error = Self::Error>, [src]
Si2: Sink<Item, Error = Self::Error>,
fn right_sink<Si1>(self) -> Either<Si1, Self>ⓘ where
Si1: Sink<Item, Error = Self::Error>, [src]
Si1: Sink<Item, Error = Self::Error>,
fn compat(self) -> CompatSink<Self, Item> where
Self: Unpin, [src]
Self: Unpin,
fn poll_ready_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>> where
Self: Unpin, [src]
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>> where
Self: Unpin,
fn start_send_unpin(&mut self, item: Item) -> Result<(), Self::Error> where
Self: Unpin, [src]
Self: Unpin,
fn poll_flush_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>> where
Self: Unpin, [src]
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>> where
Self: Unpin,
fn poll_close_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>> where
Self: Unpin, [src]
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>> where
Self: Unpin,
impl<T> StreamExt for T where
T: Stream + ?Sized, [src]
T: Stream + ?Sized,
fn next(&mut self) -> Next<'_, Self>ⓘ where
Self: Unpin, [src]
Self: Unpin,
fn into_future(self) -> StreamFuture<Self>ⓘ where
Self: Unpin, [src]
Self: Unpin,
fn map<T, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> T, [src]
F: FnMut(Self::Item) -> T,
fn enumerate(self) -> Enumerate<Self>[src]
fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>, [src]
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = Option<T>>, [src]
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = Option<T>>,
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future, [src]
F: FnMut(Self::Item) -> Fut,
Fut: Future,
fn collect<C>(self) -> Collect<Self, C>ⓘ where
C: Default + Extend<Self::Item>, [src]
C: Default + Extend<Self::Item>,
fn concat(self) -> Concat<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,
fn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F>ⓘ where
F: FnMut(T, Self::Item) -> Fut,
Fut: Future<Output = T>, [src]
F: FnMut(T, Self::Item) -> Fut,
Fut: Future<Output = T>,
fn flatten(self) -> Flatten<Self> where
Self::Item: Stream, [src]
Self::Item: Stream,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: Stream, [src]
F: FnMut(Self::Item) -> U,
U: Stream,
fn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F> where
F: FnMut(&mut S, Self::Item) -> Fut,
Fut: Future<Output = Option<B>>, [src]
F: FnMut(&mut S, Self::Item) -> Fut,
Fut: Future<Output = Option<B>>,
fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>, [src]
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>, [src]
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut> where
Fut: Future, [src]
Fut: Future,
fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F>ⓘ where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>, [src]
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
fn for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> ForEachConcurrent<Self, Fut, F>ⓘ where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>, [src]
self,
limit: impl Into<Option<usize>>,
f: F
) -> ForEachConcurrent<Self, Fut, F>ⓘ where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
fn take(self, n: usize) -> Take<Self>[src]
fn skip(self, n: usize) -> Skip<Self>[src]
fn fuse(self) -> Fuse<Self>[src]
fn by_ref(&mut self) -> &mut Selfⓘ[src]
fn catch_unwind(self) -> CatchUnwind<Self> where
Self: UnwindSafe, [src]
Self: UnwindSafe,
fn boxed<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a + Send>>ⓘ where
Self: Send + 'a, [src]
Self: Send + 'a,
fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a>>ⓘ where
Self: 'a, [src]
Self: 'a,
fn buffered(self, n: usize) -> Buffered<Self> where
Self::Item: Future, [src]
Self::Item: Future,
fn buffer_unordered(self, n: usize) -> BufferUnordered<Self> where
Self::Item: Future, [src]
Self::Item: Future,
fn zip<St>(self, other: St) -> Zip<Self, St> where
St: Stream, [src]
St: Stream,
fn chain<St>(self, other: St) -> Chain<Self, St> where
St: Stream<Item = Self::Item>, [src]
St: Stream<Item = Self::Item>,
fn peekable(self) -> Peekable<Self>[src]
fn chunks(self, capacity: usize) -> Chunks<Self>[src]
fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>[src]
fn forward<S>(self, sink: S) -> Forward<Self, S>ⓘ where
S: Sink<Self::Ok, Error = Self::Error>,
Self: TryStream, [src]
S: Sink<Self::Ok, Error = Self::Error>,
Self: TryStream,
fn split<Item>(self) -> (SplitSink<Self, Item>, SplitStream<Self>) where
Self: Sink<Item>, [src]
Self: Sink<Item>,
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item), [src]
F: FnMut(&Self::Item),
fn left_stream<B>(self) -> Either<Self, B>ⓘ where
B: Stream<Item = Self::Item>, [src]
B: Stream<Item = Self::Item>,
fn right_stream<B>(self) -> Either<B, Self>ⓘ where
B: Stream<Item = Self::Item>, [src]
B: Stream<Item = Self::Item>,
fn poll_next_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> where
Self: Unpin, [src]
Self: Unpin,
fn select_next_some(&mut self) -> SelectNextSome<'_, Self>ⓘNotable traits for SelectNextSome<'_, St>
impl<'_, St> Future for SelectNextSome<'_, St> where
St: Unpin + FusedStream + ?Sized, type Output = <St as Stream>::Item; where
Self: Unpin + FusedStream, [src]
Notable traits for SelectNextSome<'_, St>
impl<'_, St> Future for SelectNextSome<'_, St> where
St: Unpin + FusedStream + ?Sized, type Output = <St as Stream>::Item;Self: Unpin + FusedStream,
impl<T> ToOwned for T where
T: Clone, [src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T[src]
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.
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>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]
impl<S, T, E> TryStream for S where
S: Stream<Item = Result<T, E>> + ?Sized, [src]
S: Stream<Item = Result<T, E>> + ?Sized,
type Ok = T
The type of successful values yielded by this future
type Error = E
The type of failures yielded by this future
fn try_poll_next(
self: Pin<&mut S>,
cx: &mut Context<'_>
) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>[src]
self: Pin<&mut S>,
cx: &mut Context<'_>
) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>
impl<S> TryStreamExt for S where
S: TryStream + ?Sized, [src]
S: TryStream + ?Sized,
fn err_into<E>(self) -> ErrInto<Self, E> where
Self::Error: Into<E>, [src]
Self::Error: Into<E>,
fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> where
F: FnMut(Self::Ok) -> T, [src]
F: FnMut(Self::Ok) -> T,
fn map_err<E, F>(self, f: F) -> MapErr<Self, F> where
F: FnMut(Self::Error) -> E, [src]
F: FnMut(Self::Error) -> E,
fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>, [src]
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> where
F: FnMut(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>, [src]
F: FnMut(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> where
F: FnMut(&Self::Ok), [src]
F: FnMut(&Self::Ok),
fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where
F: FnMut(&Self::Error), [src]
F: FnMut(&Self::Error),
fn into_stream(self) -> IntoStream<Self>[src]
fn try_next(&mut self) -> TryNext<'_, Self>ⓘ where
Self: Unpin, [src]
Self: Unpin,
fn try_for_each<Fut, F>(self, f: F) -> TryForEach<Self, Fut, F>ⓘ where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = (), Error = Self::Error>, [src]
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = (), Error = Self::Error>,
fn try_skip_while<Fut, F>(self, f: F) -> TrySkipWhile<Self, Fut, F> where
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>, [src]
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
fn try_take_while<Fut, F>(self, f: F) -> TryTakeWhile<Self, Fut, F> where
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>, [src]
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
fn try_for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> TryForEachConcurrent<Self, Fut, F>ⓘ where
F: FnMut(Self::Ok) -> Fut,
Fut: Future<Output = Result<(), Self::Error>>, [src]
self,
limit: impl Into<Option<usize>>,
f: F
) -> TryForEachConcurrent<Self, Fut, F>ⓘ where
F: FnMut(Self::Ok) -> Fut,
Fut: Future<Output = Result<(), Self::Error>>,
fn try_collect<C>(self) -> TryCollect<Self, C>ⓘ where
C: Default + Extend<Self::Ok>, [src]
C: Default + Extend<Self::Ok>,
fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F> where
F: FnMut(&Self::Ok) -> Fut,
Fut: Future<Output = bool>, [src]
F: FnMut(&Self::Ok) -> Fut,
Fut: Future<Output = bool>,
fn try_filter_map<Fut, F, T>(self, f: F) -> TryFilterMap<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = Option<T>, Error = Self::Error>, [src]
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = Option<T>, Error = Self::Error>,
fn try_flatten(self) -> TryFlatten<Self> where
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error: From<Self::Error>, [src]
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error: From<Self::Error>,
fn try_fold<T, Fut, F>(self, init: T, f: F) -> TryFold<Self, Fut, T, F>ⓘ where
F: FnMut(T, Self::Ok) -> Fut,
Fut: TryFuture<Ok = T, Error = Self::Error>, [src]
F: FnMut(T, Self::Ok) -> Fut,
Fut: TryFuture<Ok = T, Error = Self::Error>,
fn try_concat(self) -> TryConcat<Self>ⓘNotable traits for TryConcat<St>
impl<St> Future for TryConcat<St> where
St: TryStream,
<St as TryStream>::Ok: Extend<<<St as TryStream>::Ok as IntoIterator>::Item>,
<St as TryStream>::Ok: IntoIterator,
<St as TryStream>::Ok: Default, type Output = Result<<St as TryStream>::Ok, <St as TryStream>::Error>; where
Self::Ok: Extend<<Self::Ok as IntoIterator>::Item>,
Self::Ok: IntoIterator,
Self::Ok: Default, [src]
Notable traits for TryConcat<St>
impl<St> Future for TryConcat<St> where
St: TryStream,
<St as TryStream>::Ok: Extend<<<St as TryStream>::Ok as IntoIterator>::Item>,
<St as TryStream>::Ok: IntoIterator,
<St as TryStream>::Ok: Default, type Output = Result<<St as TryStream>::Ok, <St as TryStream>::Error>;Self::Ok: Extend<<Self::Ok as IntoIterator>::Item>,
Self::Ok: IntoIterator,
Self::Ok: Default,
fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error, [src]
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
fn try_poll_next_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Option<Result<Self::Ok, Self::Error>>> where
Self: Unpin, [src]
&mut self,
cx: &mut Context<'_>
) -> Poll<Option<Result<Self::Ok, Self::Error>>> where
Self: Unpin,
fn compat(self) -> Compat<Self>ⓘ where
Self: Unpin, [src]
Self: Unpin,
fn into_async_read(self) -> IntoAsyncRead<Self> where
Self: TryStreamExt<Error = Error> + Unpin,
Self::Ok: AsRef<[u8]>, [src]
Self: TryStreamExt<Error = Error> + Unpin,
Self::Ok: AsRef<[u8]>,