fn perform(&self) -> Result<Self::Output, Self::Error> {
        let mut rx = self
            .0
            .lock()
            .map_err(|_| "Could not obtain lock on receiver".to_string())?;

        // Attempt to read from the channel. Block for at most 100 ms.
        match rx.try_next() {
            Ok(event) => Ok(event),
            Err(_) => Ok(None),
        }
    }
/// The work performed on the `libuv` thread. First acquire a lock on
/// the receiving thread and then return the received data.
/// In practice, this should never need to wait for a lock since it
/// should only be executed one at a time by the `EventEmitter` class.
The work performed on the `libuv` thread. First acquire a lock on
the receiving thread and then return the received data.
In practice, this should never need to wait for a lock since it
should only be executed one at a time by the `EventEmitter` class.
The work performed on the ` libuv ` thread . First acquire a lock on the receiving thread and then return the received data . In practice this should never need to wait for a lock since it should only be executed one at a time by the ` EventEmitter ` class .
fn perform(&self) -> Result<Self::Output, Self::Error> {
        let mut rx = self
            .0
            .lock()
            .map_err(|_| "Could not obtain lock on receiver".to_string())?;
        // Attempt to read from the channel. Block for at most 100 ms.
        match rx.try_next() {
            Ok(event) => Ok(event),
            Err(_) => Ok(None),
        }
    }
fn perform ( & self ) -> Result < Self :: Output , Self :: Error > { let mut rx = self . 0 . lock ( ) . map_err ( | _ | " " . to_string ( ) ) ? ; // Attempt to read from the channel. Block for at most 100 ms. match rx . try_next ( ) { Ok ( event ) => Ok ( event ) , Err ( _ ) => Ok ( None ) , } }
The work performed on the `libuv` thread.
The work performed on the ` libuv ` thread .
&self
&self