Struct amadeus_core::par_stream::ClonedTask

pub struct ClonedTask<T> { /* fields omitted */ }

Trait Implementations

impl<'de, T> Deserialize<'de> for ClonedTask<T> where
    T: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T> PinnedDrop for ClonedTask<T>

unsafe fn drop(self: Pin<&mut Self>)

impl<'a, C, Input: 'a, T: 'a> Pipe<&'a Input> for ClonedTask<C> where
    C: Pipe<&'a Input, Output = &'a T>,
    T: Clone, 

type Output = T

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = &'a Input>>
) -> Poll<Option<Self::Output>>

fn pipe<P>(self, pipe: P) -> PipePipe<Self, P> where
    P: Pipe<Self::Output>,
    Self: Sized, 

fn sink<S>(self, sink: S) -> PipeSink<Self, S> where
    S: Sink<Self::Output>,
    Self: Sized, 

fn filter<F>(self, f: F) -> Filter<Self, F> where
    F: FnMut(&Self::Output) -> bool,
    Self: Sized, 

fn flat_map<F, R>(self, f: F) -> FlatMap<Self, F, R> where
    F: FnMut(Self::Output) -> R,
    R: Stream,
    Self: Sized, 

fn flatten(self) -> Flatten<Self, Self::Output> where
    Self::Output: Stream,
    Self: Sized, 

fn map<F, R>(self, f: F) -> Map<Self, F> where
    F: FnMut(Self::Output) -> R,
    Self: Sized, 

impl<'a, C, Input, T: 'a> PipeTask<&'a Input> for ClonedTask<C> where
    C: PipeTask<&'a Input, Output = &'a T>,
    T: Clone, 

type Output = T

type Async = ClonedTask<C::Async>

fn into_async(self) -> Self::Async

impl<T> Serialize for ClonedTask<T> where
    T: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<'pin, T> Unpin for ClonedTask<T> where
    __ClonedTask<'pin, T>: Unpin, 

impl<T> UnsafeUnpin for ClonedTask<T>