Method poll_write

opensuse-proxy-cache/src/main.rs:695–788

Required methods

(
        mut self: Pin<&mut Self>,
        cx: &mut Context<'_>,
        buf: &[u8],
    )

{
    // Required methods
    fn poll_write(
        mut self: Pin<&mut Self>,
        cx: &mut Context<'_>,
        buf: &[u8],
    ) -> Poll<std::io::Result<usize>> {
        let mut this = self.as_mut().project();

        // Any leftover "needs" from previous loop?
        match *this.sink_b_state {
            SinkState::Needs(amt) => {
                let res_b = if buf.len() > amt {
                    this.sink_b.poll_write(cx, &buf[..amt])
                } else {
                    this.sink_b.poll_write(cx, buf)
                };

                let res_b = match res_b {
                    Poll::Ready(Ok(wrote_b)) if wrote_b == amt => {
                        *this.sink_b_state = SinkState::Ready;
                        Poll::Ready(Ok(wrote_b))
                    }
                    Poll::Ready(Ok(wrote_b)) => {
                        assert!(amt > wrote_b);
                        *this.sink_b_state = SinkState::Needs(amt - wrote_b);
                        Poll::Ready(Ok(wrote_b))
                    }
                    Poll::Ready(Err(_)) => {
                        *this.sink_b_state = SinkState::Err;
                        // We need to convince the caller that we wrote the amount needed,
                        // so return that we wrote amt.
                        Poll::Ready(Ok(amt))
                    }
                    Poll::Pending => Poll::Pending,
                };

                return res_b;
            }
            SinkState::Err | SinkState::Ready => {
                // proceed
            }
        };

        // Write to the first sink.
        let res_a = this.sink_a.poll_write(cx, buf);
        // save the result.

        // based on the result, choose how to write to the second sink.
        match (res_a, *this.sink_b_state) {
            (Poll::Ready(Ok(wrote_a)), SinkState::Ready) => {
                let res_b = if buf.len() > wrote_a {
                    this.sink_b.poll_write(cx, &buf[..wrote_a])
                } else {
                    this.sink_b.poll_write(cx, buf)
                };

                match res_b {
                    Poll::Ready(Ok(wrote_b)) if wrote_b == wrote_a => {
                        *this.sink_b_state = SinkState::Ready;