Trait MultipartWriteExt 

pub trait MultipartWriteExt<Part>: MultipartWrite<Part> {
    // Provided methods
    fn and_then<T, E, Fut, F>(self, f: F) -> AndThen<Self, Fut, F>
       where F: FnMut(Self::Output) -> Fut,
             Fut: Future<Output = Result<T, E>>,
             E: From<Self::Error>,
             Self: Sized { ... }
    fn boxed<'a>(
        self,
    ) -> BoxMultipartWrite<'a, Part, Self::Ret, Self::Output, Self::Error>
       where Self: Sized + Send + 'a { ... }
    fn boxed_local<'a>(
        self,
    ) -> LocalBoxMultipartWrite<'a, Part, Self::Ret, Self::Output, Self::Error>
       where Self: Sized + 'a { ... }
    fn buffered(
        self,
        capacity: impl Into<Option<usize>>,
    ) -> Buffered<Self, Part>
       where Self: Sized { ... }
    fn complete(&mut self) -> Complete<'_, Self, Part> 
       where Self: Unpin { ... }
    fn fanout<U>(self, other: U) -> Fanout<Self, U, Part>
       where Part: Clone,
             U: MultipartWrite<Part, Error = Self::Error>,
             Self: Sized { ... }
    fn feed(&mut self, part: Part) -> Feed<'_, Self, Part> 
       where Self: Unpin { ... }
    fn filter<F>(self, f: F) -> Filter<Self, F>
       where F: FnMut(&Part) -> bool,
             Self: Sized { ... }
    fn filter_map<U, F>(self, f: F) -> FilterMap<Self, F>
       where F: FnMut(U) -> Option<Part>,
             Self: Sized { ... }
    fn flush(&mut self) -> Flush<'_, Self, Part> 
       where Self: Unpin { ... }
    fn fold_ret<T, F>(self, id: T, f: F) -> FoldRet<Self, T, F>
       where F: FnMut(T, &Self::Ret) -> T,
             Self: Sized { ... }
    fn fuse<F>(self, f: F) -> Fuse<Self, F>
       where F: FnMut(&Self::Output) -> bool,
             Self: Sized { ... }
    fn lift<U, T>(self, other: U) -> Lift<Self, U, Part>
       where Self: Sized,
             Self::Error: From<U::Error>,
             U: MultipartWrite<T, Output = Part> { ... }
    fn map_err<E, F>(self, f: F) -> MapErr<Self, F>
       where F: FnMut(Self::Error) -> E,
             Self: Sized { ... }
    fn map_ok<U, F>(self, f: F) -> MapOk<Self, F>
       where F: FnMut(Self::Output) -> U,
             Self: Sized { ... }
    fn map_ret<U, F>(self, f: F) -> MapRet<Self, F>
       where F: FnMut(Self::Ret) -> U,
             Self: Sized { ... }
    fn poll_ready_unpin(
        &mut self,
        cx: &mut Context<'_>,
    ) -> Poll<Result<(), Self::Error>>
       where Self: Unpin { ... }
    fn poll_flush_unpin(
        &mut self,
        cx: &mut Context<'_>,
    ) -> Poll<Result<(), Self::Error>>
       where Self: Unpin { ... }
    fn poll_complete_unpin(
        &mut self,
        cx: &mut Context<'_>,
    ) -> Poll<Result<Self::Output, Self::Error>>
       where Self: Unpin { ... }
    fn send_part(&mut self, part: Part) -> SendPart<'_, Self, Part> 
       where Self: Unpin { ... }
    fn then<T, E, Fut, F>(self, f: F) -> Then<Self, Fut, F>
       where F: FnMut(Result<Self::Output, Self::Error>) -> Fut,
             Fut: Future<Output = Result<T, E>>,
             E: From<Self::Error>,
             Self: Sized { ... }
    fn with<U, E, Fut, F>(self, f: F) -> With<Self, Part, Fut, F>
       where F: FnMut(U) -> Fut,
             Fut: Future<Output = Result<Part, E>>,
             E: From<Self::Error>,
             Self: Sized { ... }
}

An extension trait for MultipartWrite providing a variety of convenient combinator functions.

Provided Methods

fn and_then<T, E, Fut, F>(self, f: F) -> AndThen<Self, Fut, F>

where F: FnMut(Self::Output) -> Fut, Fut: Future<Output = Result<T, E>>, E: From<Self::Error>, Self: Sized,

Compute from this writer’s output type a new output of a different type using an asynchronous closure.

Calling poll_complete on this writer will complete the inner writer, then run the provided closure f with the output to produce the final output of this writer.

fn boxed<'a>( self, ) -> BoxMultipartWrite<'a, Part, Self::Ret, Self::Output, Self::Error>

where Self: Sized + Send + 'a,

Wrap this writer in a Box, pinning it.

fn boxed_local<'a>( self, ) -> LocalBoxMultipartWrite<'a, Part, Self::Ret, Self::Output, Self::Error>

where Self: Sized + 'a,

Wrap this writer in a Box, pinning it.

Similar to boxed but without the Send requirement.

fn buffered(self, capacity: impl Into<Option<usize>>) -> Buffered<Self, Part>

where Self: Sized,

Adds a fixed size buffer to the current writer.

The resulting MultipartWrite will buffer up to capacity items when the underlying writer is not able to accept new parts.

fn complete(&mut self) -> Complete<'_, Self, Part>

where Self: Unpin,

A future that runs this writer to completion, returning the associated output.

fn fanout<U>(self, other: U) -> Fanout<Self, U, Part>

where Part: Clone, U: MultipartWrite<Part, Error = Self::Error>, Self: Sized,

Fanout the part to multiple writers.

This adapter clones each incoming part and forwards it to both writers.

fn feed(&mut self, part: Part) -> Feed<'_, Self, Part>

where Self: Unpin,

A future that completes after the given part has been received by the writer.

Unlike send_part, the returned future does not flush the writer. It is the caller’s responsibility to ensure all pending items are processed, which can be done with flush or complete.

fn filter<F>(self, f: F) -> Filter<Self, F>

where F: FnMut(&Part) -> bool, Self: Sized,

Apply a filter to this writer’s parts, returning a new writer with the same output.

The return type of this writer is Option<Self::Ret> and is None when the part did not pass the filter.

fn filter_map<U, F>(self, f: F) -> FilterMap<Self, F>

where F: FnMut(U) -> Option<Part>, Self: Sized,

Attempt to map the input to a part for this writer, filtering out the inputs where the mapping returns None.

The return type of this writer is Option<Self::Ret> and is None when the mapping of the input U did not pass the filter.

fn flush(&mut self) -> Flush<'_, Self, Part>

where Self: Unpin,

A future that completes when the underlying writer has been flushed.

fn fold_ret<T, F>(self, id: T, f: F) -> FoldRet<Self, T, F>

where F: FnMut(T, &Self::Ret) -> T, Self: Sized,

Accumulate this writer’s returned values, returning a new multipart writer that pairs the underlying writer’s output with the result of the accumulating function.

fn fuse<F>(self, f: F) -> Fuse<Self, F>

where F: FnMut(&Self::Output) -> bool, Self: Sized,

Returns a new writer that fuses according to the provided closure.

The resulting writer wraps both Self::Ret and Self::Output in an Option and is guaranted to both output and return Ok(None) when called after becoming fused.

fn lift<U, T>(self, other: U) -> Lift<Self, U, Part>

where Self: Sized, Self::Error: From<U::Error>, U: MultipartWrite<T, Output = Part>,

“Lift” the multipart writer U in front of this one.

The result is a new multipart writer that writes parts for U, using the output of U to source the parts to write to this writer, and resolving to the output of this writer when polled to completion.

In other words, it expresses this multipart writer as being built from the parts of another multipart writer.

fn map_err<E, F>(self, f: F) -> MapErr<Self, F>

where F: FnMut(Self::Error) -> E, Self: Sized,

Map this writer’s error type to a different value, returning a new multipart writer with the given error type.

fn map_ok<U, F>(self, f: F) -> MapOk<Self, F>

where F: FnMut(Self::Output) -> U, Self: Sized,

Map this writer’s output type to a different type, returning a new multipart writer with the given output type.

fn map_ret<U, F>(self, f: F) -> MapRet<Self, F>

where F: FnMut(Self::Ret) -> U, Self: Sized,

Map this writer’s return type to a different value, returning a new multipart writer with the given return type.

fn poll_ready_unpin( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

where Self: Unpin,

A convenience method for calling MultipartWrite::poll_ready on Unpin writer types.

fn poll_flush_unpin( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

where Self: Unpin,

A convenience method for calling MultipartWrite::poll_flush on Unpin writer types.

fn poll_complete_unpin( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<Self::Output, Self::Error>>

where Self: Unpin,

A convenience method for calling MultipartWrite::poll_complete on Unpin writer types.

fn send_part(&mut self, part: Part) -> SendPart<'_, Self, Part>

where Self: Unpin,

A future that completes when a part has been fully processed into the writer, including flushing.

fn then<T, E, Fut, F>(self, f: F) -> Then<Self, Fut, F>

where F: FnMut(Result<Self::Output, Self::Error>) -> Fut, Fut: Future<Output = Result<T, E>>, E: From<Self::Error>, Self: Sized,

Chain an asynchronous computation on the result of polling the writer for completion.

fn with<U, E, Fut, F>(self, f: F) -> With<Self, Part, Fut, F>

where F: FnMut(U) -> Fut, Fut: Future<Output = Result<Part, E>>, E: From<Self::Error>, Self: Sized,

Provide a part to this writer in the output of a future.

The result is a new writer over the type U that passes each value through the function f, resolving the output, and sending it to the inner writer.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<Wr: MultipartWrite<Part>, Part> MultipartWriteExt<Part> for Wr