pub fn need_read(&mut self) -> io::Result<()> {
        let bits = super::ready2usize(super::read_ready());
        self.readiness &= !bits;

        let inner = match self.handle.inner() {
            Some(inner) => inner,
            None => return Err(io::Error::new(io::ErrorKind::Other, "reactor gone")),
        };
        inner.schedule(self.token, Direction::Read);
        Ok(())
    }
/// Indicates to this source of events that the corresponding I/O object is
/// no longer readable, but it needs to be.
///
/// This function, like `poll_read`, is only safe to call from the context
/// of a future's task (typically in a `Future::poll` implementation). It
/// informs this readiness stream that the underlying object is no longer
/// readable, typically because a "would block" error was seen.
///
/// *All* readiness bits associated with this stream except the writable bit
/// will be reset when this method is called. The current task is then
/// scheduled to receive a notification whenever anything changes other than
/// the writable bit. Note that this typically just means the readable bit
/// is used here, but if you're using a custom I/O object for events like
/// hup/error this may also be relevant.
///
/// Note that it is also only valid to call this method if `poll_read`
/// previously indicated that the object is readable. That is, this function
/// must always be paired with calls to `poll_read` previously.
///
/// # Errors
///
/// This function will return an error if the `Reactor` that this `PollEvented`
/// is associated with has gone away (been destroyed). The error means that
/// the ambient futures task could not be scheduled to receive a
/// notification and typically means that the error should be propagated
/// outwards.
///
/// # Panics
///
/// This function will panic if called outside the context of a future's
/// task.
Indicates to this source of events that the corresponding I/O object is
no longer readable, but it needs to be.

This function, like `poll_read`, is only safe to call from the context
of a future's task (typically in a `Future::poll` implementation). It
informs this readiness stream that the underlying object is no longer
readable, typically because a "would block" error was seen.

All* readiness bits associated with this stream except the writable bit
will be reset when this method is called. The current task is then
scheduled to receive a notification whenever anything changes other than
the writable bit. Note that this typically just means the readable bit
is used here, but if you're using a custom I/O object for events like
hup/error this may also be relevant.

Note that it is also only valid to call this method if `poll_read`
previously indicated that the object is readable. That is, this function
must always be paired with calls to `poll_read` previously.
Indicates to this source of events that the corresponding I / O object is no longer readable but it needs to be . This function like ` poll_read ` is only safe to call from the context of a future ' s task ( typically in a ` Future :: poll ` implementation ) . It informs this readiness stream that the underlying object is no longer readable typically because a " would block " error was seen . All * readiness bits associated with this stream except the writable bit will be reset when this method is called . The current task is then scheduled to receive a notification whenever anything changes other than the writable bit . Note that this typically just means the readable bit is used here but if you ' re using a custom I / O object for events like hup / error this may also be relevant . Note that it is also only valid to call this method if ` poll_read ` previously indicated that the object is readable . That is this function must always be paired with calls to ` poll_read ` previously .
pub fn need_read(&mut self) -> io::Result<()> {
        let bits = super::ready2usize(super::read_ready());
        self.readiness &= !bits;
        let inner = match self.handle.inner() {
            Some(inner) => inner,
            None => return Err(io::Error::new(io::ErrorKind::Other, "reactor gone")),
        };
        inner.schedule(self.token, Direction::Read);
        Ok(())
    }
pub fn need_read ( & mut self ) -> io :: Result < ( ) > { let bits = super :: ready2usize ( super :: read_ready ( ) ) ; self . readiness &= ! bits ; let inner = match self . handle . inner ( ) { Some ( inner ) => inner , None => return Err ( io :: Error :: new ( io :: ErrorKind :: Other , " " ) ) , } ; inner . schedule ( self . token , Direction :: Read ) ; Ok ( ( ) ) }
Indicates to this source of events that the corresponding I/O object is
no longer readable, but it needs to be.
Indicates to this source of events that the corresponding I / O object is no longer readable but it needs to be .
&mut self
&mut self
errors
This function will return an error if the `Reactor` that this `PollEvented`
is associated with has gone away (been destroyed). The error means that
the ambient futures task could not be scheduled to receive a
notification and typically means that the error should be propagated
outwards.
This function will return an error if the ` Reactor ` that this ` PollEvented ` is associated with has gone away ( been destroyed ) . The error means that the ambient futures task could not be scheduled to receive a notification and typically means that the error should be propagated outwards .
panics
This function will panic if called outside the context of a future's
task.
This function will panic if called outside the context of a future ' s task .