Struct calloop::generic::Generic

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

A generic event source wrapping a FD-backed type

Fields

file: F

The wrapped FD-backed type

interest: Interest

The programmed interest

mode: Mode

The programmed mode

Implementations

impl<F: AsRawFd> Generic<F, Error>

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

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: AsRawFd, E> Generic<F, E>

pub fn unwrap(self) -> F

Unwrap the Generic source to retrieve the underlying type

Trait Implementations

impl<F: Debug + AsRawFd, E: Debug> Debug for Generic<F, E>

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

Formats the value using the given formatter.

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

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

type Event = Readiness

The type of events generated by your source.

type Metadata = 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, Self::Error>

where C: FnMut(Self::Event, &mut Self::Metadata) -> Self::Ret,

Process any relevant events

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

Register yourself to this poll instance

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

Re-register your file descriptors

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

Unregister your file descriptors

fn pre_run<F>(&mut self, _callback: F) -> Result<()>

where F: FnMut(Self::Event, &mut Self::Metadata) -> Self::Ret,

Notification that a polling session is going to start

fn post_run<F>(&mut self, _callback: F) -> Result<()>

where F: FnMut(Self::Event, &mut Self::Metadata) -> Self::Ret,

Notification that the current polling session ended