Trait mio::event::Source

pub trait Source {
    // Required methods
    fn register(
        &mut self,
        registry: &Registry,
        token: Token,
        interests: Interest,
    ) -> Result<()>;
    fn reregister(
        &mut self,
        registry: &Registry,
        token: Token,
        interests: Interest,
    ) -> Result<()>;
    fn deregister(&mut self, registry: &Registry) -> Result<()>;
}

An event source that may be registered with Registry.

Types that implement event::Source can be registered with Registry. Users of Mio should not use the event::Source trait functions directly. Instead, the equivalent functions on Registry should be used.

See Registry for more details.

Implementing event::Source

Event sources are always backed by system handles, such as sockets or other system handles. These event::Sources will be monitored by the system selector. An implementation of Source will almost always delegates to a lower level handle. Examples of this are TcpStreams, or the unix only SourceFd.

Dropping event::Sources

All event::Sources, unless otherwise specified, need to be deregistered before being dropped for them to not leak resources. This goes against the normal drop behaviour of types in Rust which cleanup after themselves, e.g. a File will close itself. However since deregistering needs access to Registry this cannot be done while being dropped.

Examples

Implementing Source on a struct containing a socket:

use mio::{Interest, Registry, Token};
use mio::event::Source;
use mio::net::TcpStream;

use std::io;

pub struct MySource {
    socket: TcpStream,
}

impl Source for MySource {
    fn register(&mut self, registry: &Registry, token: Token, interests: Interest)
        -> io::Result<()>
    {
        // Delegate the `register` call to `socket`
        self.socket.register(registry, token, interests)
    }

    fn reregister(&mut self, registry: &Registry, token: Token, interests: Interest)
        -> io::Result<()>
    {
        // Delegate the `reregister` call to `socket`
        self.socket.reregister(registry, token, interests)
    }

    fn deregister(&mut self, registry: &Registry) -> io::Result<()> {
        // Delegate the `deregister` call to `socket`
        self.socket.deregister(registry)
    }
}

Required Methods

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

Register self with the given Registry instance.

This function should not be called directly. Use Registry::register instead. Implementors should handle registration by delegating the call to another Source type.

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

Re-register self with the given Registry instance.

This function should not be called directly. Use Registry::reregister instead. Implementors should handle re-registration by either delegating the call to another Source type.

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

Deregister self from the given Registry instance.

This function should not be called directly. Use Registry::deregister instead. Implementors should handle deregistration by delegating the call to another Source type.

Implementations on Foreign Types

impl<T> Source for Box<T>

where T: Source + ?Sized,

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

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

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

Implementors

impl Source for TcpListener

impl Source for TcpStream

impl Source for UdpSocket

impl Source for UnixDatagram

impl Source for UnixListener

impl Source for UnixStream

impl Source for Receiver

impl Source for Sender

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