[−][src]Trait mio::event::Evented

pub trait Evented {
    pub fn register(
        &self, 
        poll: &Poll, 
        token: Token, 
        interest: Ready, 
        opts: PollOpt
    ) -> Result<()>;

    pub fn reregister(
        &self, 
        poll: &Poll, 
        token: Token, 
        interest: Ready, 
        opts: PollOpt
    ) -> Result<()>;

    pub fn deregister(&self, poll: &Poll) -> Result<()>;
}

A value that may be registered with Poll

Values that implement Evented can be registered with Poll. Users of Mio should not use the Evented trait functions directly. Instead, the equivalent functions on Poll should be used.

See Poll for more details.

Implementing Evented

There are two types of Evented values.

  • System handles, which are backed by sockets or other system handles. These Evented handles will be monitored by the system selector. In this case, an implementation of Evented delegates to a lower level handle.

  • User handles, which are driven entirely in user space using Registration and SetReadiness. In this case, the implementer takes responsibility for driving the readiness state changes.

Examples

Implementing Evented on a struct containing a socket:

use mio::{Ready, Poll, PollOpt, Token};
use mio::event::Evented;
use mio::net::TcpStream;

use std::io;

pub struct MyEvented {
    socket: TcpStream,
}

impl Evented for MyEvented {
    fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt)
        -> io::Result<()>
    {
        // Delegate the `register` call to `socket`
        self.socket.register(poll, token, interest, opts)
    }

    fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt)
        -> io::Result<()>
    {
        // Delegate the `reregister` call to `socket`
        self.socket.reregister(poll, token, interest, opts)
    }

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

Implement Evented using Registration and SetReadiness.

use mio::{Ready, Registration, Poll, PollOpt, Token};
use mio::event::Evented;

use std::io;
use std::time::Instant;
use std::thread;

pub struct Deadline {
    when: Instant,
    registration: Registration,
}

impl Deadline {
    pub fn new(when: Instant) -> Deadline {
        let (registration, set_readiness) = Registration::new2();

        thread::spawn(move || {
            let now = Instant::now();

            if now < when {
                thread::sleep(when - now);
            }

            set_readiness.set_readiness(Ready::readable());
        });

        Deadline {
            when: when,
            registration: registration,
        }
    }

    pub fn is_elapsed(&self) -> bool {
        Instant::now() >= self.when
    }
}

impl Evented for Deadline {
    fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt)
        -> io::Result<()>
    {
        self.registration.register(poll, token, interest, opts)
    }

    fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt)
        -> io::Result<()>
    {
        self.registration.reregister(poll, token, interest, opts)
    }

    fn deregister(&self, poll: &Poll) -> io::Result<()> {
        self.registration.deregister(poll)
    }
}

Required methods

pub fn register(
    &self,
    poll: &Poll,
    token: Token,
    interest: Ready,
    opts: PollOpt
) -> Result<()>[src]

Register self with the given Poll instance.

This function should not be called directly. Use Poll::register instead. Implementors should handle registration by either delegating the call to another Evented type or creating a Registration.

pub fn reregister(
    &self,
    poll: &Poll,
    token: Token,
    interest: Ready,
    opts: PollOpt
) -> Result<()>[src]

Re-register self with the given Poll instance.

This function should not be called directly. Use Poll::reregister instead. Implementors should handle re-registration by either delegating the call to another Evented type or calling SetReadiness::set_readiness.

pub fn deregister(&self, poll: &Poll) -> Result<()>[src]

Deregister self from the given Poll instance

This function should not be called directly. Use Poll::deregister instead. Implementors should handle deregistration by either delegating the call to another Evented type or by dropping the Registration associated with self.

Loading content...

Implementations on Foreign Types

impl Evented for Box<dyn Evented>[src]

impl<T: Evented> Evented for Box<T>[src]

impl<T: Evented> Evented for Arc<T>[src]

Loading content...

Implementors

impl Evented for TcpListener[src]

impl Evented for TcpStream[src]

impl Evented for UdpSocket[src]

impl Evented for Registration[src]

impl<'a> Evented for EventedFd<'a>[src]

Loading content...