     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37

    use {Ready, Token};
    use deprecated::{EventLoop};

    #[allow(unused_variables)]
    pub trait Handler: Sized {
        type Timeout;
        type Message;

        /// Invoked when the socket represented by `token` is ready to be operated
        /// on. `events` indicates the specific operations that are
        /// ready to be performed.
        ///
        /// For example, when a TCP socket is ready to be read from, `events` will
        /// have `readable` set. When the socket is ready to be written to,
        /// `events` will have `writable` set.
        ///
        /// This function will only be invoked a single time per socket per event
        /// loop tick.
        fn ready(&mut self, event_loop: &mut EventLoop<Self>, token: Token, events: Ready) {
        }

        /// Invoked when a message has been received via the event loop's channel.
        fn notify(&mut self, event_loop: &mut EventLoop<Self>, msg: Self::Message) {
        }

        /// Invoked when a timeout has completed.
        fn timeout(&mut self, event_loop: &mut EventLoop<Self>, timeout: Self::Timeout) {
        }

        /// Invoked when `EventLoop` has been interrupted by a signal interrupt.
        fn interrupted(&mut self, event_loop: &mut EventLoop<Self>) {
        }

        /// Invoked at the end of an event loop tick.
        fn tick(&mut self, event_loop: &mut EventLoop<Self>) {
        }
    }

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)