impl Receiver

fn set_nonblocking(self: &Self, nonblocking: bool) -> Result<()>

Set the Receiver into or out of non-blocking mode.

fn try_io<F, T>(self: &Self, f: F) -> Result<T>
where
    F: FnOnce() -> Result<T>

Execute an I/O operation ensuring that the socket receives more events if it hits a WouldBlock error.

Notes

This method is required to be called for all I/O operations to ensure the user will receive events once the socket is ready again after returning a WouldBlock error.

Examples

# use std::error::Error;
#
# fn main() -> Result<(), Box<dyn Error>> {
use std::io;
use std::os::fd::AsRawFd;
use mio::unix::pipe;

let (sender, receiver) = pipe::new()?;

// Wait until the sender is writable...

// Write to the sender using a direct libc call, of course the
// `io::Write` implementation would be easier to use.
let buf = b"hello";
let n = sender.try_io(|| {
    let buf_ptr = &buf as *const _ as *const _;
    let res = unsafe { libc::write(sender.as_raw_fd(), buf_ptr, buf.len()) };
    if res != -1 {
        Ok(res as usize)
    } else {
        // If EAGAIN or EWOULDBLOCK is set by libc::write, the closure
        // should return `WouldBlock` error.
        Err(io::Error::last_os_error())
    }
})?;
eprintln!("write {} bytes", n);

// Wait until the receiver is readable...

// Read from the receiver using a direct libc call, of course the
// `io::Read` implementation would be easier to use.
let mut buf = [0; 512];
let n = receiver.try_io(|| {
    let buf_ptr = &mut buf as *mut _ as *mut _;
    let res = unsafe { libc::read(receiver.as_raw_fd(), buf_ptr, buf.len()) };
    if res != -1 {
        Ok(res as usize)
    } else {
        // If EAGAIN or EWOULDBLOCK is set by libc::read, the closure
        // should return `WouldBlock` error.
        Err(io::Error::last_os_error())
    }
})?;
eprintln!("read {} bytes", n);
# Ok(())
# }

impl AsFd for Receiver

fn as_fd(self: &Self) -> BorrowedFd<'_>

impl AsRawFd for Receiver

fn as_raw_fd(self: &Self) -> RawFd

impl Debug for Receiver

fn fmt(self: &Self, f: &mut Formatter<'_>) -> Result

impl Freeze for Receiver

impl From for Receiver

fn from(stdout: ChildStdout) -> Receiver

impl From for Receiver

fn from(stderr: ChildStderr) -> Receiver

impl From for Receiver

fn from(fd: OwnedFd) -> Self

impl FromRawFd for Receiver

unsafe fn from_raw_fd(fd: RawFd) -> Receiver

impl IntoRawFd for Receiver

fn into_raw_fd(self: Self) -> RawFd

impl Read for Receiver

fn read(self: &mut Self, buf: &mut [u8]) -> Result<usize>

fn read_vectored(self: &mut Self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize>

impl RefUnwindSafe for Receiver

impl Send for Receiver

impl Source for Receiver

fn register(self: &mut Self, registry: &Registry, token: Token, interests: Interest) -> Result<()>

fn reregister(self: &mut Self, registry: &Registry, token: Token, interests: Interest) -> Result<()>

fn deregister(self: &mut Self, registry: &Registry) -> Result<()>

impl Sync for Receiver

impl Unpin for Receiver

impl UnsafeUnpin for Receiver

impl UnwindSafe for Receiver

impl<T> Any for Receiver

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for Receiver

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for Receiver

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> From for Receiver

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for Receiver

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for Receiver

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for Receiver

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>