Struct Flatten

#[must_use = "futures/streams/sinks do nothing unless you `.await` or poll them"]
pub struct Flatten<St>
where
    St: Stream, { /* private fields */ }

Stream for the flatten method.

Implementations

impl<St> Flatten<St> where St: Stream,

fn get_ref(&self) -> &St

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

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

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 St>

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) -> St

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, St> Unpin for Flatten<St> where PinnedFieldsOf<__Origin<'__pin, St>>: Unpin, St: Stream,

impl<St> Debug for Flatten<St> where Flatten<St, St::Item>: Debug, St: Stream,

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

impl<St> FusedStream for Flatten<St> where Flatten<St, St::Item>: FusedStream, St: Stream,

fn is_terminated(&self) -> bool

impl<St> Stream for Flatten<St> where Flatten<St, St::Item>: Stream, St: Stream,

type Item = <Flatten<St, <St as Stream>::Item> 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<_Item, St> Sink<_Item> for Flatten<St> where Flatten<St, St::Item>: Sink<_Item>, St: Stream,

type Error = <Flatten<St, <St as Stream>::Item> as Sink<_Item>>::Error;
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>>

Auto Trait Implementations

impl<St> Freeze for Flatten<St> where Flatten<St, <St as Stream>::Item>: Freeze,

impl<St> RefUnwindSafe for Flatten<St> where Flatten<St, <St as Stream>::Item>: RefUnwindSafe,

impl<St> Send for Flatten<St> where Flatten<St, <St as Stream>::Item>: Send,

impl<St> Sync for Flatten<St> where Flatten<St, <St as Stream>::Item>: Sync,

impl<St> UnsafeUnpin for Flatten<St> where Flatten<St, <St as Stream>::Item>: UnsafeUnpin,

impl<St> UnwindSafe for Flatten<St> where Flatten<St, <St as Stream>::Item>: UnwindSafe,

Blanket Implementations

impl<S> TryStreamExt for Flatten<St> where S: TryStream + ?Sized,

impl<S, T, E> TryStream for Flatten<St> 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 Flatten<St> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Flatten<St> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Flatten<St> where T: ?Sized,

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

impl<T> From<T> for Flatten<St>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> StreamExt for Flatten<St> where T: Stream + ?Sized,

impl<T, Item> SinkExt<Item> for Flatten<St> where T: Sink<Item> + ?Sized,

impl<T, U> Into<U> for Flatten<St> 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 Flatten<St> where U: Into<T>,

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

impl<T, U> TryInto<U> for Flatten<St> where U: TryFrom<T>,

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