Struct SourceFd

pub struct SourceFd<'a>(pub &'a RawFd);

Adapter for RawFd providing an event::Source implementation.

SourceFd enables registering any type with an FD with Poll.

While only implementations for TCP and UDP are provided, Mio supports registering any FD that can be registered with the underlying OS selector. SourceFd provides the necessary bridge.

Note that SourceFd takes a &RawFd. This is because SourceFd does not take ownership of the FD. Specifically, it will not manage any lifecycle related operations, such as closing the FD on drop. It is expected that the SourceFd is constructed right before a call to Registry::register. See the examples for more detail.

Examples

Basic usage.

use mio::{Interest, Poll, Token};
use mio::unix::SourceFd;

use std::os::fd::AsRawFd;
use std::net::TcpListener;

// Bind a std listener
let listener = TcpListener::bind("127.0.0.1:0")?;

let poll = Poll::new()?;

// Register the listener
poll.registry().register(
    &mut SourceFd(&listener.as_raw_fd()),
    Token(0),
    Interest::READABLE)?;

Implementing event::Source for a custom type backed by a RawFd.

use mio::{event, Interest, Registry, Token};
use mio::unix::SourceFd;

use std::os::fd::RawFd;
use std::io;

pub struct MyIo {
    fd: RawFd,
}

impl event::Source for MyIo {
    fn register(&mut self, registry: &Registry, token: Token, interests: Interest)
        -> io::Result<()>
    {
        SourceFd(&self.fd).register(registry, token, interests)
    }

    fn reregister(&mut self, registry: &Registry, token: Token, interests: Interest)
        -> io::Result<()>
    {
        SourceFd(&self.fd).reregister(registry, token, interests)
    }

    fn deregister(&mut self, registry: &Registry) -> io::Result<()> {
        SourceFd(&self.fd).deregister(registry)
    }
}

Tuple Fields

0: &'a RawFd

Trait Implementations

impl<'a> Debug for SourceFd<'a>

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

Formats the value using the given formatter.

impl<'a> Source for SourceFd<'a>

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

Register self with the given Registry instance.

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

Re-register self with the given Registry instance.

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

Deregister self from the given Registry instance.