Struct ws::util::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::tcp::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().unwrap();

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

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

// Spawn a thread that will connect a bunch of sockets then close them
let addr = listener.local_addr().unwrap();
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).unwrap();

    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;
                            }

                            // 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()).unwrap();

                            // 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
                            continue;
                        }
                        e => panic!("err={:?}", e), // Unexpected error
                    }
                }
            }
        }
    }
}

Trait Implementations

impl PartialOrd<Token> for Token

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

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

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

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

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

impl Copy for Token

impl Ord for Token

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

impl PartialEq<Token> for Token

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

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

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

This method tests for !=.

impl From<usize> for Token

fn from(val: usize) -> Token

Performs the conversion.

impl Eq for Token

impl Hash for Token

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

impl Debug for Token

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.

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.