Struct ClonedTask 

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

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<'a, C, Input: 'a, T> Pipe<&'a Input> for ClonedTask<C>

where C: Pipe<&'a Input, Output = &'a T>, T: Clone + 'a,

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> PipeTask<&'a Input> for ClonedTask<C>

where C: PipeTask<&'a Input, Output = &'a T>, T: Clone + 'a,

type Output = T

type Async = ClonedTask<<C as PipeTask<&'a Input>>::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>