## Token

# Struct Token

Source

    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§

Source§

### impl Clone for Token

Source§

#### fn clone(&self) -> Token

Returns a duplicate of the value. Read more
1.0.0 · Source§

#### fn clone_from(&mut self, source: &Self)

Performs copy-assignment from `source`. Read more
Source§

### impl Debug for Token

Source§

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

Formats the value using the given formatter. Read more
Source§

### impl From<Token> for usize

Source§

#### fn from(val: Token) -> usize

Converts to this type from the input type.
Source§

### impl Hash for Token

Source§

#### fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given `Hasher`. Read more
1.3.0 · Source§

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

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

### impl Ord for Token

Source§

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

This method returns an `Ordering` between `self` and `other`. Read more
1.21.0 · Source§

#### fn max(self, other: Self) -> Self
where Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · Source§

#### fn min(self, other: Self) -> Self
where Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · Source§

#### fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized,

Restrict a value to a certain interval. Read more
Source§

### impl PartialEq for Token

Source§

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

Tests for `self` and `other` values to be equal, and is used by `==`.
1.0.0 · Source§

#### fn ne(&self, other: &Rhs) -> bool

Tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source§

### impl PartialOrd for Token

Source§

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

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

#### fn lt(&self, other: &Rhs) -> bool

Tests less than (for `self` and `other`) and is used by the `<` operator. Read more
1.0.0 · Source§

#### fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more
1.0.0 · Source§

#### fn gt(&self, other: &Rhs) -> bool

Tests greater than (for `self` and `other`) and is used by the `>` operator. Read more
1.0.0 · Source§

#### fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more
Source§

### impl Copy for Token

Source§

### impl Eq for Token

Source§

### impl StructuralPartialEq for Token

## Auto Trait Implementations§

§

### impl Freeze for Token

§

### impl RefUnwindSafe for Token

§

### impl Send for Token

§

### impl Sync for Token

§

### impl Unpin for Token

§

### impl UnwindSafe for Token

## Blanket Implementations§

Source§

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

Source§

#### fn type_id(&self) -> TypeId

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

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

Source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

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

Source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

### impl<T> CloneToUninit for T
where T: Clone,

Source§

#### unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (`clone_to_uninit`)
Performs copy-assignment from `self` to `dest`. Read more
Source§

### impl<T> From<T> for T

Source§

#### fn from(t: T) -> T

Returns the argument unchanged.

Source§

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

Source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

Source§

### impl<T> ToOwned for T
where T: Clone,

Source§

#### type Owned = T

The resulting type after obtaining ownership.
Source§

#### fn to_owned(&self) -> T

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

#### fn clone_into(&self, target: &mut T)

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

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

Source§

#### type Error = Infallible

The type returned in the event of a conversion error.
Source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

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

Source§

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

The type returned in the event of a conversion error.
Source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.