Struct Generic

pub struct Generic<F, E = Error>
where
    F: AsFd,
{
    pub interest: Interest,
    pub mode: Mode,
    /* private fields */
}

Available on crate feature wayland and Linux only.

A generic event source wrapping a FD-backed type

Fields

interest: Interest

The programmed interest

mode: Mode

The programmed mode

Implementations

impl<F> Generic<F>

where F: AsFd,

pub fn new(file: F, interest: Interest, mode: Mode) -> Generic<F>

Wrap a FD-backed type into a Generic event source that uses std::io::Error as its error type.

pub fn new_with_error<E>( file: F, interest: Interest, mode: Mode, ) -> Generic<F, E>

Wrap a FD-backed type into a Generic event source using an arbitrary error type.

impl<F, E> Generic<F, E>

where F: AsFd,

pub fn unwrap(self) -> F

Unwrap the Generic source to retrieve the underlying type

pub fn get_ref(&self) -> &F

Get a reference to the underlying type.

pub unsafe fn get_mut(&mut self) -> &mut F

Get a mutable reference to the underlying type.

Safety

This is unsafe because it allows you to modify the underlying type, which allows you to drop the underlying event source. Dropping the underlying source leads to a dangling reference.

Trait Implementations

impl<F, E> Debug for Generic<F, E>

where F: Debug + AsFd, E: Debug,

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

Formats the value using the given formatter.

impl<F, E> Drop for Generic<F, E>

where F: AsFd,

fn drop(&mut self)

Executes the destructor for this type.

impl<F, E> EventSource for Generic<F, E>

where F: AsFd, E: Into<Box<dyn Error + Sync + Send>>,

type Event = Readiness

The type of events generated by your source.

type Metadata = NoIoDrop<F>

Some metadata of your event source

type Ret = Result<PostAction, E>

The return type of the user callback

type Error = E

The error type returned from process_events() (not the user callback!).

fn process_events<C>( &mut self, readiness: Readiness, token: Token, callback: C, ) -> Result<PostAction, <Generic<F, E> as EventSource>::Error>

where C: FnMut(<Generic<F, E> as EventSource>::Event, &mut <Generic<F, E> as EventSource>::Metadata) -> <Generic<F, E> as EventSource>::Ret,

Process any relevant events

fn register( &mut self, poll: &mut Poll, token_factory: &mut TokenFactory, ) -> Result<(), Error>

Register yourself to this poll instance

fn reregister( &mut self, poll: &mut Poll, token_factory: &mut TokenFactory, ) -> Result<(), Error>

Re-register your file descriptors

fn unregister(&mut self, poll: &mut Poll) -> Result<(), Error>

Unregister your file descriptors

const NEEDS_EXTRA_LIFECYCLE_EVENTS: bool = false

Whether this source needs to be sent the EventSource::before_sleep and EventSource::before_handle_events notifications. These are opt-in because they require more expensive checks, and almost all sources will not need these notifications

fn before_sleep(&mut self) -> Result<Option<(Readiness, Token)>, Error>

Notification that a single poll is about to begin

fn before_handle_events(&mut self, events: EventIterator<'_>)

Notification that polling is complete, and EventSource::process_events will be called with the given events for this source. The iterator may be empty, which indicates that no events were generated for this source