Trait MultipartWrite 

pub trait MultipartWrite<Part> {
    type Ret;
    type Output;
    type Error;

    // Required methods
    fn poll_ready(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>,
    ) -> Poll<Result<(), Self::Error>>;
    fn start_send(
        self: Pin<&mut Self>,
        part: Part,
    ) -> Result<Self::Ret, Self::Error>;
    fn poll_flush(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>,
    ) -> Poll<Result<(), Self::Error>>;
    fn poll_complete(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>,
    ) -> Poll<Result<Self::Output, Self::Error>>;
}

MultipartWrite is a Sink-like interface for asynchronously writing an object in parts.

Required Associated Types

type Ret

The type of value returned when writing the part began successfully.

type Output

The type of value returned when all parts are written.

type Error

The type of value returned when an operation fails.

Required Methods

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

Attempts to prepare the MultipartWrite to receive a new part.

This method must be called and return Poll::Ready before each call to start_send, indicating that the underlying writer is ready to have another part written to it.

This method returns Poll::Pending when the object being prepared cannot accept another part.

fn start_send( self: Pin<&mut Self>, part: Part, ) -> Result<Self::Ret, Self::Error>

Begin the process of writing a part to this writer, returning the associated type confirming this was done successfully.

Like Sink, this should be preceded by a call to poll_ready that returns Poll::Ready to ensure that the MultipartWrite is ready to receive a new part.

Errors

Errors returned by this method are implementation-specific, but it is always an error to call start_send when poll_ready would return Poll::Pending.

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

Flush any remaining output from the writer.

Returns Poll::Ready when no parts remain and Poll::Pending if there is more work left to do.

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

Complete this writer, returning the output.

This method returns Poll::Pending until no buffered, unwritten parts remain and the complete output object is available.

Implementations on Foreign Types

impl<P, Part> MultipartWrite<Part> for Pin<P>

where P: DerefMut + Unpin, P::Target: MultipartWrite<Part>,

type Ret = <<P as Deref>::Target as MultipartWrite<Part>>::Ret

type Output = <<P as Deref>::Target as MultipartWrite<Part>>::Output

type Error = <<P as Deref>::Target as MultipartWrite<Part>>::Error

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

fn start_send( self: Pin<&mut Self>, part: Part, ) -> Result<Self::Ret, Self::Error>

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

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

impl<W: ?Sized + MultipartWrite<Part> + Unpin, Part> MultipartWrite<Part> for &mut W

type Ret = <W as MultipartWrite<Part>>::Ret

type Output = <W as MultipartWrite<Part>>::Output

type Error = <W as MultipartWrite<Part>>::Error

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

fn start_send( self: Pin<&mut Self>, part: Part, ) -> Result<Self::Ret, Self::Error>

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

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

Implementors

impl<U, Wr, F, Part> MultipartWrite<Part> for Map<Wr, F>

where Wr: MultipartWrite<Part>, F: FnMut(Wr::Output) -> U,

type Ret = <Wr as MultipartWrite<Part>>::Ret

type Output = U

type Error = <Wr as MultipartWrite<Part>>::Error

impl<U, Wr, F, Part> MultipartWrite<Part> for MapRet<Wr, F>

where Wr: MultipartWrite<Part>, F: FnMut(Wr::Ret) -> U,

type Ret = U

type Output = <Wr as MultipartWrite<Part>>::Output

type Error = <Wr as MultipartWrite<Part>>::Error

impl<U, Wr, F, Part> MultipartWrite<U> for MapPart<Wr, F>

where Wr: MultipartWrite<Part>, F: FnMut(U) -> Result<Part, Wr::Error>,

type Ret = <Wr as MultipartWrite<Part>>::Ret

type Output = <Wr as MultipartWrite<Part>>::Output

type Error = <Wr as MultipartWrite<Part>>::Error

impl<W: Write + Default> MultipartWrite<&[u8]> for MultiIoWriter<W>

type Ret = usize

type Output = W

type Error = Error

impl<W: AsyncWrite + Default + Unpin> MultipartWrite<&[u8]> for MultiAsyncWriter<W>

Available on crate feature tokio only.

type Ret = usize

type Output = W

type Error = Error

impl<Wr1, Wr2, Part> MultipartWrite<Part> for Fanout<Wr1, Wr2, Part>

where Part: Clone, Wr1: MultipartWrite<Part>, Wr2: MultipartWrite<Part, Error = Wr1::Error>,

type Ret = (<Wr1 as MultipartWrite<Part>>::Ret, <Wr2 as MultipartWrite<Part>>::Ret)

type Output = (<Wr1 as MultipartWrite<Part>>::Output, <Wr2 as MultipartWrite<Part>>::Output)

type Error = <Wr1 as MultipartWrite<Part>>::Error

impl<Wr, F, Fut, Part> MultipartWrite<Part> for Then<Wr, F, Fut>

where Wr: MultipartWrite<Part>, F: FnMut(Wr::Output) -> Fut, Fut: Future,

type Ret = <Wr as MultipartWrite<Part>>::Ret

type Output = <Fut as Future>::Output

type Error = <Wr as MultipartWrite<Part>>::Error

impl<Wr, F, Part, E> MultipartWrite<Part> for MapErr<Wr, F>

where Wr: MultipartWrite<Part>, F: FnMut(Wr::Error) -> E,

type Ret = <Wr as MultipartWrite<Part>>::Ret

type Output = <Wr as MultipartWrite<Part>>::Output

type Error = E

impl<Wr, F, T, Part> MultipartWrite<Part> for FoldRet<Wr, F, T>

where Wr: MultipartWrite<Part>, F: FnMut(T, &Wr::Ret) -> T,

type Ret = <Wr as MultipartWrite<Part>>::Ret

type Output = (T, <Wr as MultipartWrite<Part>>::Output)

type Error = <Wr as MultipartWrite<Part>>::Error

impl<Wr, Part> MultipartWrite<Part> for Buffered<Wr, Part>

where Wr: MultipartWrite<Part>,

type Ret = ()

type Output = <Wr as MultipartWrite<Part>>::Output

type Error = <Wr as MultipartWrite<Part>>::Error

impl<Wr, Part, U, Fut, F, E> MultipartWrite<U> for With<Wr, Part, U, Fut, F>

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

type Ret = ()

type Output = <Wr as MultipartWrite<Part>>::Output

type Error = E

impl<Wr, S, F, Fut, Part> MultipartWrite<Part> for OnComplete<Wr, S, F, Fut>

where Wr: MultipartWrite<Part>, F: FnMut(&mut S) -> Fut, Fut: Future<Output = Result<Wr, Wr::Error>>,

type Ret = <Wr as MultipartWrite<Part>>::Ret

type Output = <Wr as MultipartWrite<Part>>::Output

type Error = <Wr as MultipartWrite<Part>>::Error