fn read_to_end_internal<R: AsyncRead + ?Sized>(
    rd: &mut R,
    cx: &mut task::Context,
    buf: &mut Vec<u8>,
) -> Poll<io::Result<()>> {
    let mut g = Guard { len: buf.len(), buf };
    let ret;
    loop {
        if g.len == g.buf.len() {
            unsafe {
                g.buf.reserve(32);
                let capacity = g.buf.capacity();
                g.buf.set_len(capacity);
                rd.initializer().initialize(&mut g.buf[g.len..]);
            }
        }

        match rd.poll_read(cx, &mut g.buf[g.len..]) {
            Poll::Ready(Ok(0)) => {
                ret = Poll::Ready(Ok(()));
                break;
            }
            Poll::Ready(Ok(n)) => g.len += n,
            Poll::Pending => return Poll::Pending,
            Poll::Ready(Err(e)) => {
                ret = Poll::Ready(Err(e));
                break;
            }
        }
    }

    ret
}
// This uses an adaptive system to extend the vector when it fills. We want to
// avoid paying to allocate and zero a huge chunk of memory if the reader only
// has 4 bytes while still making large reads if the reader does have a ton
// of data to return. Simply tacking on an extra DEFAULT_BUF_SIZE space every
// time is 4,500 times (!) slower than this if the reader has a very small
// amount of data to return.
//
// Because we're extending the buffer with uninitialized data for trusted
// readers, we need to make sure to truncate that if any of this panics.
This uses an adaptive system to extend the vector when it fills. We want to
avoid paying to allocate and zero a huge chunk of memory if the reader only
has 4 bytes while still making large reads if the reader does have a ton
of data to return. Simply tacking on an extra DEFAULT_BUF_SIZE space every
time is 4,500 times (!) slower than this if the reader has a very small
amount of data to return.

Because we're extending the buffer with uninitialized data for trusted
readers, we need to make sure to truncate that if any of this panics.
This uses an adaptive system to extend the vector when it fills . We want to avoid paying to allocate and zero a huge chunk of memory if the reader only has 4 bytes while still making large reads if the reader does have a ton of data to return . Simply tacking on an extra DEFAULT_BUF_SIZE space every time is 4 500 times ( ! ) slower than this if the reader has a very small amount of data to return . Because we ' re extending the buffer with uninitialized data for trusted readers we need to make sure to truncate that if any of this panics .
fn read_to_end_internal<R: AsyncRead + ?Sized>(
    rd: &mut R,
    cx: &mut task::Context,
    buf: &mut Vec<u8>,
) -> Poll<io::Result<()>> {
    let mut g = Guard { len: buf.len(), buf };
    let ret;
    loop {
        if g.len == g.buf.len() {
            unsafe {
                g.buf.reserve(32);
                let capacity = g.buf.capacity();
                g.buf.set_len(capacity);
                rd.initializer().initialize(&mut g.buf[g.len..]);
            }
        }
        match rd.poll_read(cx, &mut g.buf[g.len..]) {
            Poll::Ready(Ok(0)) => {
                ret = Poll::Ready(Ok(()));
                break;
            }
            Poll::Ready(Ok(n)) => g.len += n,
            Poll::Pending => return Poll::Pending,
            Poll::Ready(Err(e)) => {
                ret = Poll::Ready(Err(e));
                break;
            }
        }
    }
    ret
}
fn read_to_end_internal < R : AsyncRead + ? Sized > ( rd : & mut R , cx : & mut task :: Context , buf : & mut Vec < u8 > , ) -> Poll < io :: Result < ( ) > > { let mut g = Guard { len : buf . len ( ) , buf } ; let ret ; loop { if g . len == g . buf . len ( ) { unsafe { g . buf . reserve ( 32 ) ; let capacity = g . buf . capacity ( ) ; g . buf . set_len ( capacity ) ; rd . initializer ( ) . initialize ( & mut g . buf [ g . len .. ] ) ; } } match rd . poll_read ( cx , & mut g . buf [ g . len .. ] ) { Poll :: Ready ( Ok ( 0 ) ) => { ret = Poll :: Ready ( Ok ( ( ) ) ) ; break ; } Poll :: Ready ( Ok ( n ) ) => g . len += n , Poll :: Pending => return Poll :: Pending , Poll :: Ready ( Err ( e ) ) => { ret = Poll :: Ready ( Err ( e ) ) ; break ; } } } ret }
This uses an adaptive system to extend the vector when it fills.
This uses an adaptive system to extend the vector when it fills .
rd
&mut R
cx
&mut task::Context
buf
&mut Vec<u8>