fn result(&mut self) -> io::Result<bool> {
        let amt = match self.state {
            State::NotReading => return Ok(true),
            State::Reading => {
                self.pipe.overlapped_result(&mut *self.overlapped, true)?
            }
            State::Read(amt) => amt,
        };
        self.state = State::NotReading;
        unsafe {
            let len = self.dst.len();
            self.dst.set_len(len + amt);
        }
        Ok(amt != 0)
    }
/// Wait for the result of the overlapped operation previously executed.
///
/// Takes a parameter `wait` which indicates if this pipe is currently being
/// read whether the function should block waiting for the read to complete.
///
/// Return values:
///
/// * `true` - finished any pending read and the pipe is not at EOF (keep
///            going)
/// * `false` - finished any pending read and pipe is at EOF (stop issuing
///             reads)
Wait for the result of the overlapped operation previously executed.
Takes a parameter `wait` which indicates if this pipe is currently being
read whether the function should block waiting for the read to complete.

Return values.

`true` - finished any pending read and the pipe is not at EOF (keep
going)
`false` - finished any pending read and pipe is at EOF (stop issuing
reads)
Wait for the result of the overlapped operation previously executed . Takes a parameter ` wait ` which indicates if this pipe is currently being read whether the function should block waiting for the read to complete . Return values . ` true ` - finished any pending read and the pipe is not at EOF ( keep going ) ` false ` - finished any pending read and pipe is at EOF ( stop issuing reads )
fn result(&mut self) -> io::Result<bool> {
        let amt = match self.state {
            State::NotReading => return Ok(true),
            State::Reading => {
                self.pipe.overlapped_result(&mut *self.overlapped, true)?
            }
            State::Read(amt) => amt,
        };
        self.state = State::NotReading;
        unsafe {
            let len = self.dst.len();
            self.dst.set_len(len + amt);
        }
        Ok(amt != 0)
    }
fn result ( & mut self ) -> io :: Result < bool > { let amt = match self . state { State :: NotReading => return Ok ( true ) , State :: Reading => { self . pipe . overlapped_result ( & mut * self . overlapped , true ) ? } State :: Read ( amt ) => amt , } ; self . state = State :: NotReading ; unsafe { let len = self . dst . len ( ) ; self . dst . set_len ( len + amt ) ; } Ok ( amt != 0 ) }
Wait for the result of the overlapped operation previously executed.
Wait for the result of the overlapped operation previously executed .
&mut self
&mut self