Struct mio::Token[][src]

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 Copy for Token
[src]

impl Clone for Token
[src]

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

impl Debug for Token
[src]

Formats the value using the given formatter. Read more

impl PartialEq for Token
[src]

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

This method tests for !=.

impl Eq for Token
[src]

impl PartialOrd for Token
[src]

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

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

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

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

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

impl Ord for Token
[src]

This method returns an Ordering between self and other. Read more

Compares and returns the maximum of two values. Read more

Compares and returns the minimum of two values. Read more

impl Hash for Token
[src]

Feeds this value into the given [Hasher]. Read more

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

impl From<usize> for Token
[src]

Performs the conversion.

impl From<Token> for usize
[src]

Performs the conversion.

Auto Trait Implementations

impl Send for Token

impl Sync for Token