/// 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.

///

/// [`event::Source`]: ./event/trait.Source.html

/// [`Poll`]: struct.Poll.html

/// [`Registry::register`]: struct.Registry.html#method.register

/// [`Registry::reregister`]: struct.Registry.html#method.reregister

///

/// # Example

///

/// Using `Token` to track which socket generated the event. In this example,

/// `HashMap` is used, but usually something like [`slab`] is better.

///

/// [`slab`]: https://crates.io/crates/slab

///

#[cfg_attr(all(feature = "os-poll", feature = "net"), doc = "```")]

#[cfg_attr(not(all(feature = "os-poll", feature = "net")), doc = "```ignore")]

/// # use std::error::Error;

/// # fn main() -> Result<(), Box<dyn Error>> {

/// # // WASI does not yet support multithreading:

/// # if cfg!(target_os = "wasi") { return Ok(()) }

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

///                     }

///                 }

///             }

///         }

///     }

/// }

/// # }

/// ```

#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]

pub struct Token(pub usize);

impl From<Token> for usize {

    fn from(val: Token) -> usize {

        val.0

    }

}