Struct mio::Token[][src]

pub struct Token(pub usize);

Associates readiness events with event::Sources.

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

See Poll for more documentation on polling.


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

use mio::{Events, Interest, Poll, 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 mut poll = Poll::new()?;

// Tcp listener
let mut listener = TcpListener::bind("".parse()?)?;

// Register the listener
poll.registry().register(&mut listener, LISTENER, Interest::READABLE)?;

// 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((mut 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.registry().register(&mut socket, token, Interest::READABLE)?;

                            // Store the socket
                            sockets.insert(token, socket);
                        Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
                            // Socket is not ready anymore, stop accepting
                        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
                        // 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
                        e => panic!("err={:?}", e), // Unexpected error

Trait Implementations

impl Clone for Token[src]

impl Copy for Token[src]

impl Debug for Token[src]

impl Eq for Token[src]

impl Hash for Token[src]

impl Ord for Token[src]

impl PartialEq<Token> for Token[src]

impl PartialOrd<Token> for Token[src]

impl StructuralEq for Token[src]

impl StructuralPartialEq for Token[src]

Auto Trait Implementations

impl RefUnwindSafe for Token

impl Send for Token

impl Sync for Token

impl Unpin for Token

impl UnwindSafe for Token

Blanket Implementations

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

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

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

impl<T> From<T> for T[src]

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

impl<T> ToOwned for T where
    T: Clone

type Owned = T

The resulting type after obtaining ownership.

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

type Error = Infallible

The type returned in the event of a conversion error.

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

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

The type returned in the event of a conversion error.