Struct mio::Token [−][src]
pub struct Token(pub usize);
Expand description
Associates readiness events with event::Source
s.
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.
Example
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("127.0.0.1:0".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
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
}
}
}
}
}
}
Tuple Fields
0: usize
Trait Implementations
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
Auto Trait Implementations
impl RefUnwindSafe for Token
impl UnwindSafe for Token
Blanket Implementations
Mutably borrows from an owned value. Read more