Trait MultipartWrite

Source

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>>;
}

Expand description

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

Required Associated Types§

Source

type Ret

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

Source

type Output

The type of value returned when all parts are written.

Source

type Error

The type of value returned when an operation fails.

Required Methods§

Source

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.

In most cases, if the writer encounters an error, it will be permanently unable to write more parts.

Source

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.

In most cases, if the writer encounters an error, it will be permanently unable to write more parts.

Source

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 buffered, unwritten parts remain and Poll::Pending if there is more work left to do.

In most cases, if the writer encounters an error, it will be permanently unable to write more parts.

Source

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.

In most cases, if the writer encounters an error, it will be permanently unable to write more parts.

MultipartWrite

Trait MultipartWrite Copy item path

Required Associated Types§

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>

§Errors

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

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<T> MultipartWrite<T> for VecDeque<T>

type Ret = ()

type Output = VecDeque<T>

type Error = Infallible

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

fn start_send(self: Pin<&mut Self>, part: T) -> 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<T> MultipartWrite<T> for Vec<T>

type Ret = ()

type Output = Vec<T>

type Error = Infallible

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

fn start_send(self: Pin<&mut Self>, part: T) -> 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<Item, Wr, F> MultipartWrite<Item> for Fuse<Wr, F>where Wr: MultipartWrite<Item>, F: FnMut(&Wr::Output) -> bool,

type Ret = Option<<Wr as MultipartWrite<Item>>::Ret>

type Output = Option<<Wr as MultipartWrite<Item>>::Output>

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

impl<T, A> MultipartWrite<A> for Extend<T, A>where T: Extend<A>,

type Error = Error

type Ret = ()

type Output = T

impl<T, Wr, U, Part> MultipartWrite<T> for Lift<Wr, U, Part>where U: MultipartWrite<T, Output = Part>, Wr: MultipartWrite<Part>, Wr::Error: From<U::Error>,

type Ret = <U as MultipartWrite<T>>::Ret

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

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

impl<U, E, Wr, Part, Fut, F> MultipartWrite<U> for With<Wr, Part, 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<U, Wr, F, Part> MultipartWrite<Part> for MapOk<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<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>

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)

Trait MultipartWrite

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

impl<Item, Wr, F> MultipartWrite<Item> for Fuse<Wr, F>
where Wr: MultipartWrite<Item>, F: FnMut(&Wr::Output) -> bool,

impl<T, A> MultipartWrite<A> for Extend<T, A>
where T: Extend<A>,

impl<T, Wr, U, Part> MultipartWrite<T> for Lift<Wr, U, Part>
where U: MultipartWrite<T, Output = Part>, Wr: MultipartWrite<Part>, Wr::Error: From<U::Error>,

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

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

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

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

impl<Wr, F, Part> MultipartWrite<Part> for Filter<Wr, F>
where Wr: MultipartWrite<Part>, F: FnMut(&Part) -> bool,

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

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

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

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

impl<Wr, Part, E, Fut> MultipartWrite<Part> for Resolve<Fut, Wr>
where Fut: Future<Output = Result<Wr, E>>, Wr: MultipartWrite<Part, Error = E>,

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

impl<Wr, U, Part, F> MultipartWrite<U> for FilterMap<Wr, F>
where Wr: MultipartWrite<Part>, F: FnMut(U) -> Option<Part>,