Struct calloop::generic::Generic

pub struct Generic<F: AsRawFd> {
    pub file: F,
    pub interest: Interest,
    pub mode: Mode,
    // some fields omitted
}

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>

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

Wrap a FD-backed type into a Generic event source

pub fn unwrap(self) -> F

Unwrap the Generic source to retrieve the underlying type

impl Generic<Fd>

pub fn from_fd(fd: RawFd, interest: Interest, mode: Mode) -> Generic<Fd>

Wrap a raw file descriptor into a Generic event source

Trait Implementations

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

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

Formats the value using the given formatter.

impl<F: AsRawFd> EventSource for Generic<F>

type Event = Readiness

The type of events generated by your source.

type Metadata = F

Some metadata of your event source

type Ret = Result<PostAction>

The return type of the user callback

fn process_events<C>(
    &mut self,
    readiness: Readiness,
    token: Token,
    callback: C
) -> Result<PostAction> 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