Struct Events

pub struct Events { /* private fields */ }

A collection of readiness events.

Events is passed as an argument to Poll::poll and will be used to receive any new readiness events received since the last poll. Usually, a single Events instance is created at the same time as a Poll and reused on each call to Poll::poll.

See Poll for more documentation on polling.

Examples

# use std::error::Error;
# fn main() -> Result<(), Box<dyn Error>> {
use mio::{Events, Poll};
use std::time::Duration;

let mut events = Events::with_capacity(1024);
let mut poll = Poll::new()?;
#
# assert!(events.is_empty());

// Register `event::Source`s with `poll`.

poll.poll(&mut events, Some(Duration::from_millis(100)))?;

for event in events.iter() {
    println!("Got an event for {:?}", event.token());
}
#     Ok(())
# }

Implementations

impl Events

fn with_capacity(capacity: usize) -> Events

Return a new Events capable of holding up to capacity events.

Examples

use mio::Events;

let events = Events::with_capacity(1024);
assert_eq!(1024, events.capacity());

fn capacity(&self) -> usize

Returns the number of Event values that self can hold.

use mio::Events;

let events = Events::with_capacity(1024);
assert_eq!(1024, events.capacity());

fn is_empty(&self) -> bool

Returns true if self contains no Event values.

Examples

use mio::Events;

let events = Events::with_capacity(1024);
assert!(events.is_empty());

fn iter(&self) -> Iter<'_>

Returns an iterator over the Event values.

Examples

# use std::error::Error;
# fn main() -> Result<(), Box<dyn Error>> {
use mio::{Events, Poll};
use std::time::Duration;

let mut events = Events::with_capacity(1024);
let mut poll = Poll::new()?;

// Register handles with `poll`.

poll.poll(&mut events, Some(Duration::from_millis(100)))?;

for event in events.iter() {
    println!("Got an event for {:?}", event.token());
}
#     Ok(())
# }

fn clear(&mut self)

Clearing all Event values from container explicitly.

Notes

Events are cleared before every poll, so it is not required to call this manually.

Examples

# use std::error::Error;
# fn main() -> Result<(), Box<dyn Error>> {
use mio::{Events, Poll};
use std::time::Duration;

let mut events = Events::with_capacity(1024);
let mut poll = Poll::new()?;

// Register handles with `poll`.

poll.poll(&mut events, Some(Duration::from_millis(100)))?;

// Clear all events.
events.clear();
assert!(events.is_empty());
#     Ok(())
# }

Trait Implementations

impl Debug for Events

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

Auto Trait Implementations

impl Freeze for Events

impl RefUnwindSafe for Events

impl Send for Events

impl Sync for Events

impl Unpin for Events

impl UnsafeUnpin for Events

impl UnwindSafe for Events

Blanket Implementations

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

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

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

impl<T> From<T> for Events

fn from(t: T) -> T

Returns the argument unchanged.

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

fn into(self) -> U

Calls U::from(self).

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

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

type Error = never;
fn try_from(value: U) -> Result<T, never>

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

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