Struct SinkErrInto

#[must_use = "sinks do nothing unless polled"]
pub struct SinkErrInto<Si: Sink<Item>, Item, E> { /* private fields */ }

Sink for the sink_err_into method.

Implementations

impl<Si, E, Item> SinkErrInto<Si, Item, E> where Si: Sink<Item>, Si::Error: Into<E>,

fn get_ref(&self) -> &Si

Acquires a reference to the underlying sink or stream that this combinator is pulling from.

fn get_mut(&mut self) -> &mut Si

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.

fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut Si>

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.

fn into_inner(self) -> Si

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<'__pin, Si: Sink<Item>, Item, E> Unpin for SinkErrInto<Si, Item, E> where PinnedFieldsOf<__Origin<'__pin, Si, Item, E>>: Unpin,

impl<S, Item, E> FusedStream for SinkErrInto<S, Item, E> where S: Sink<Item> + FusedStream, S::Error: Into<E>,

fn is_terminated(&self) -> bool

impl<S, Item, E> Stream for SinkErrInto<S, Item, E> where S: Sink<Item> + Stream, S::Error: Into<E>,

type Item = <S as Stream>::Item;
fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>
fn size_hint(&self) -> (usize, Option<usize>)

impl<Si, Item, E> Sink<Item> for SinkErrInto<Si, Item, E> where Si: Sink<Item>, Si::Error: Into<E>,

type Error = E;
fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>
fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

impl<Si: Debug + Sink<Item>, Item: Debug, E: Debug> Debug for SinkErrInto<Si, Item, E> where Si::Error: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Auto Trait Implementations

impl<Si, Item, E> Freeze for SinkErrInto<Si, Item, E> where SinkMapErr<Si, fn(<Si as Sink<Item>>::Error) -> E>: Freeze,

impl<Si, Item, E> RefUnwindSafe for SinkErrInto<Si, Item, E> where SinkMapErr<Si, fn(<Si as Sink<Item>>::Error) -> E>: RefUnwindSafe,

impl<Si, Item, E> Send for SinkErrInto<Si, Item, E> where SinkMapErr<Si, fn(<Si as Sink<Item>>::Error) -> E>: Send,

impl<Si, Item, E> Sync for SinkErrInto<Si, Item, E> where SinkMapErr<Si, fn(<Si as Sink<Item>>::Error) -> E>: Sync,

impl<Si, Item, E> UnsafeUnpin for SinkErrInto<Si, Item, E> where SinkMapErr<Si, fn(<Si as Sink<Item>>::Error) -> E>: UnsafeUnpin,

impl<Si, Item, E> UnwindSafe for SinkErrInto<Si, Item, E> where SinkMapErr<Si, fn(<Si as Sink<Item>>::Error) -> E>: UnwindSafe,

Blanket Implementations

impl<S> TryStreamExt for SinkErrInto<Si, Item, E> where S: TryStream + ?Sized,

impl<S, T, E> TryStream for SinkErrInto<Si, Item, E> where S: Stream<Item = Result<T, E>> + ?Sized,

type Ok = T;
type Error = E;
fn try_poll_next(self: Pin<&mut S>, cx: &mut Context<'_>) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>

impl<T> Any for SinkErrInto<Si, Item, E> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for SinkErrInto<Si, Item, E> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for SinkErrInto<Si, Item, E> where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for SinkErrInto<Si, Item, E>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> StreamExt for SinkErrInto<Si, Item, E> where T: Stream + ?Sized,

impl<T, Item> SinkExt<Item> for SinkErrInto<Si, Item, E> where T: Sink<Item> + ?Sized,

impl<T, U> Into<U> for SinkErrInto<Si, Item, E> where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom<U> for SinkErrInto<Si, Item, E> where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for SinkErrInto<Si, Item, E> where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>