# [−] [src] Struct mio::Token

    pub struct Token(pub usize);

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.

ⓘThis example is not tested

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

## Trait Implementations

### `impl Clone for Token` [src]

#### `fn clone(&self) -> Token` [src]

Returns a copy of the value. Read more

#### `fn clone_from(&mut self, source: &Self)`1.0.0 [src]

Performs copy-assignment from `source`. Read more

### `impl Copy for Token` [src]

### `impl Debug for Token` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter. Read more

### `impl Eq for Token` [src]

### `impl From<Token> for usize` [src]

#### `fn from(val: Token) -> usize` [src]

Performs the conversion.

### `impl Hash for Token` [src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)` [src]

Feeds this value into the given `Hasher`. Read more

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

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

### `impl Ord for Token` [src]

#### `fn cmp(&self, other: &Token) -> Ordering` [src]

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

#### `#[must_use]fn max(self, other: Self) -> Self` 1.21.0 [src]

Compares and returns the maximum of two values. Read more

#### `#[must_use]fn min(self, other: Self) -> Self` 1.21.0 [src]

Compares and returns the minimum of two values. Read more

#### `#[must_use]fn clamp(self, min: Self, max: Self) -> Self` [src]

🔬 This is a nightly-only experimental API. (`clamp`)

Restrict a value to a certain interval. Read more

### `impl PartialEq<Token> for Token` [src]

#### `fn eq(&self, other: &Token) -> bool` [src]

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

#### `fn ne(&self, other: &Token) -> bool` [src]

This method tests for `!=`.

### `impl PartialOrd<Token> for Token` [src]

#### `fn partial_cmp(&self, other: &Token) -> Option<Ordering>` [src]

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

#### `fn lt(&self, other: &Token) -> bool` [src]

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

#### `fn le(&self, other: &Token) -> bool` [src]

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

#### `fn gt(&self, other: &Token) -> bool` [src]

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

#### `fn ge(&self, other: &Token) -> bool` [src]

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

### `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,` [src]

#### `pub fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

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

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `pub fn into(self) -> U` [src]

Performs the conversion.

### `impl<T> ToOwned for T where
T: Clone,` [src]

#### `type Owned = T`

The resulting type after obtaining ownership.

#### `pub fn to_owned(&self) -> T` [src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `pub fn clone_into(&self, target: &mut T)` [src]

🔬 This is a nightly-only experimental API. (`toowned_clone_into`)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

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

The type returned in the event of a conversion error.

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.