## SourceFd

# Struct SourceFd

Source

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

Expand description

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§

Source§

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

Source§

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

Formats the value using the given formatter. Read more
Source§

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

Source§

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

Register `self` with the given `Registry` instance. Read more
Source§

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

Re-register `self` with the given `Registry` instance. Read more
Source§

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

Deregister `self` from the given `Registry` instance. Read more

## Auto Trait Implementations§

§

### impl<'a> Freeze for SourceFd<'a>

§

### impl<'a> RefUnwindSafe for SourceFd<'a>

§

### impl<'a> Send for SourceFd<'a>

§

### impl<'a> Sync for SourceFd<'a>

§

### impl<'a> Unpin for SourceFd<'a>

§

### impl<'a> UnwindSafe for SourceFd<'a>

## Blanket Implementations§

Source§

### impl<T> Any for T
where T: 'static + ?Sized,

Source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
Source§

### impl<T> Borrow<T> for T
where T: ?Sized,

Source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

### impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

### impl<T> From<T> for T

Source§

#### fn from(t: T) -> T

Returns the argument unchanged.

Source§

### impl<T, U> Into<U> for T
where U: From<T>,

Source§

#### fn into(self) -> U

Calls `U::from(self)`.

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

Source§

### impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

#### type Error = Infallible

The type returned in the event of a conversion error.
Source§

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

Performs the conversion.
Source§

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

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

Performs the conversion.