Struct mio::Token

pub struct Token(pub usize);

Associates readiness notifications with Evented handles.

Token is a wrapper around usize and is used as an argument to Poll::register and Poll::reregister.

See Poll for more documentation on polling.

Example

Using Token to track which socket generated the notification. In this example, HashMap is used, but usually something like slab is better.

use mio::{Events, Ready, Poll, PollOpt, Token};
use mio::net::TcpListener;

use std::thread;
use std::io::{self, Read};
use std::collections::HashMap;

// After this number of sockets is accepted, the server will shutdown.
const MAX_SOCKETS: usize = 32;

// Pick a token that will not be used by any other socket and use that one
// for the listener.
const LISTENER: Token = Token(1024);

// Used to store the sockets.
let mut sockets = HashMap::new();

// This is used to generate a unique token for a socket
let mut next_socket_index = 0;

// The `Poll` instance
let poll = Poll::new()?;

// Tcp listener
let listener = TcpListener::bind(&"127.0.0.1:0".parse()?)?;

// Register the listener
poll.register(&listener,
              LISTENER,
              Ready::readable(),
              PollOpt::edge())?;

// Spawn a thread that will connect a bunch of sockets then close them
let addr = listener.local_addr()?;
thread::spawn(move || {
    use std::net::TcpStream;

    // +1 here is to connect an extra socket to signal the socket to close
    for _ in 0..(MAX_SOCKETS+1) {
        // Connect then drop the socket
        let _ = TcpStream::connect(&addr).unwrap();
    }
});

// Event storage
let mut events = Events::with_capacity(1024);

// Read buffer, this will never actually get filled
let mut buf = [0; 256];

// The main event loop
loop {
    // Wait for events
    poll.poll(&mut events, None)?;

    for event in &events {
        match event.token() {
            LISTENER => {
                // Perform operations in a loop until `WouldBlock` is
                // encountered.
                loop {
                    match listener.accept() {
                        Ok((socket, _)) => {
                            // Shutdown the server
                            if next_socket_index == MAX_SOCKETS {
                                return Ok(());
                            }

                            // Get the token for the socket
                            let token = Token(next_socket_index);
                            next_socket_index += 1;

                            // Register the new socket w/ poll
                            poll.register(&socket,
                                         token,
                                         Ready::readable(),
                                         PollOpt::edge())?;

                            // Store the socket
                            sockets.insert(token, socket);
                        }
                        Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
                            // Socket is not ready anymore, stop accepting
                            break;
                        }
                        e => panic!("err={:?}", e), // Unexpected error
                    }
                }
            }
            token => {
                // Always operate in a loop
                loop {
                    match sockets.get_mut(&token).unwrap().read(&mut buf) {
                        Ok(0) => {
                            // Socket is closed, remove it from the map
                            sockets.remove(&token);
                            break;
                        }
                        // Data is not actually sent in this example
                        Ok(_) => unreachable!(),
                        Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
                            // Socket is not ready anymore, stop reading
                            break;
                        }
                        e => panic!("err={:?}", e), // Unexpected error
                    }
                }
            }
        }
    }
}

Trait Implementations

impl Clone for Token

fn clone(&self) -> Token

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Ord for Token

fn cmp(&self, other: &Token) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

impl Eq for Token

impl From<usize> for Token

fn from(val: usize) -> Token

Performs the conversion.

impl From<Token> for usize

fn from(val: Token) -> usize

Performs the conversion.

impl Copy for Token

impl PartialOrd<Token> for Token

fn partial_cmp(&self, other: &Token) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Token) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Token) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Token) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Token) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialEq<Token> for Token

fn eq(&self, other: &Token) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Token) -> bool

This method tests for !=.

impl Debug for Token

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

Formats the value using the given formatter.

impl Hash for Token

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where     H: Hasher,

Feeds a slice of this type into the given [Hasher].