Enum dbus::WatchEvent

#[repr(C)]
pub enum WatchEvent {
    Readable,
    Writable,
    Error,
    Hangup,
}

A file descriptor to watch for incoming events (for async I/O).

Example

extern crate libc;
extern crate dbus;
fn main() {
    use dbus::{Connection, BusType, WatchEvent};
    let c = Connection::get_private(BusType::Session).unwrap();

    // Get a list of fds to poll for
    let mut fds: Vec<_> = c.watch_fds().iter().map(|w| w.to_pollfd()).collect();

    // Poll them with a 1 s timeout
    let r = unsafe { libc::poll(fds.as_mut_ptr(), fds.len() as libc::c_ulong, 1000) };
    assert!(r >= 0);

    // And handle incoming events
    for pfd in fds.iter().filter(|pfd| pfd.revents != 0) {
        for item in c.watch_handle(pfd.fd, WatchEvent::from_revents(pfd.revents)) {
            // Handle item
            println!("Received ConnectionItem: {:?}", item);
        }
    }
}

The enum is here for backwards compatibility mostly.

It should really be bitflags instead.

Variants

Readable

The fd is readable

Writable

The fd is writable

Error

An error occured on the fd

Hangup

The fd received a hangup.

Methods

impl WatchEvent

fn from_revents(revents: c_short) -> c_uint

After running poll, this transforms the revents into a parameter you can send into Connection::watch_handle

Trait Implementations

impl Debug for WatchEvent

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl PartialEq for WatchEvent

fn eq(&self, __arg_0: &WatchEvent) -> bool

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

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

This method tests for !=.

impl Copy for WatchEvent

impl Clone for WatchEvent

fn clone(&self) -> WatchEvent

Returns a copy of the value.

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

Performs copy-assignment from source.