Struct Driver 

pub struct Driver { /* private fields */ }

Implementations

impl Driver

pub fn has_pending(&mut self) -> bool

pub fn has_completion(&mut self) -> bool

pub fn park(&mut self) -> Result<()>

pub fn park_for(&mut self, duration: Duration) -> Result<()>

impl Driver

pub fn drive(&mut self) -> Result<bool>

pub fn drive_with<H: CqeRouter>(&mut self, handler: &mut H) -> Result<bool>

pub fn cancel_write(&mut self, token: Token)

pub fn cancel_accept(&mut self, token: Token)

pub fn dispatch_cqes<H: CqeRouter>(&mut self, handler: &mut H)

impl Driver

pub fn submit_only(&mut self) -> Result<()>

impl Driver

pub fn try_submit_sendmsg_raw_boxed<P>( &mut self, fd: Fd, packet: Box<P>, ) -> Result<Request<P>, (Error, Box<P>)>

where P: SendMsgPacket + Unpin + 'static,

Trait Implementations

impl DriverLifecycle for Driver

fn drive(&mut self) -> Result<bool>

fn has_pending(&mut self) -> bool

fn park(&mut self) -> Result<()>

fn park_for(&mut self, duration: Duration) -> Result<()>

fn submit_only(&mut self) -> Result<()>

fn arm_with_retry<F>(&mut self, op: F) -> bool

where F: FnMut(&mut Self) -> bool,

impl DriverOps for Driver

type Token = Token<u8>

type ProvidedRing = ProvidedRing

type IoRequest<O: Unpin + 'static> = Request<O>

fn provided_ring(&mut self) -> &mut Self::ProvidedRing

fn buf_group(&self) -> u16

fn arm_recv_multi( &mut self, token: Self::Token, fd: FixedFd, buf_group: u16, ) -> bool

unsafe fn arm_recv_msg_multi( &mut self, token: Self::Token, fd: FixedFd, buf_group: u16, msghdr: *const msghdr, ) -> bool

Safety

fn arm_accept_multi(&mut self, token: Self::Token, fd: Fd) -> bool

fn submit_send_tagged( &mut self, token: Self::Token, fd: FixedFd, ptr: *const u8, len: u32, ) -> bool

unsafe fn submit_send_msg_tagged( &mut self, token: Self::Token, fd: FixedFd, msg: *const msghdr, ) -> bool

Safety

fn cancel_recv(&mut self, token: Self::Token)

fn try_submit_connect_raw( &mut self, fd: Fd, addr: SockAddr, ) -> Result<Self::IoRequest<SockAddr>, (Error, SockAddr)>

fn try_submit_sendmsg_raw<P: SendMsgPacket + Unpin + 'static>( &mut self, fd: Fd, packet: P, ) -> Result<Self::IoRequest<P>, (Error, P)>

fn try_submit_send_raw<B: AsRef<[u8]> + Unpin + 'static>( &mut self, fd: Fd, buf: B, ) -> Result<Self::IoRequest<B>, (Error, B)>

impl Drop for Driver

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl FixedBuffers for Driver

type Guard = FixedBufGuard

fn fixed_guard(&mut self) -> Option<Self::Guard>

fn register_fixed(&mut self, fd: Fd) -> Result<Option<u32>>

fn unregister_fixed(&mut self, idx: u32)

impl ProvidedBufRing for Driver

type Provided = ProvidedBuf

fn provided_group(&mut self) -> Option<(u16, u32)>

fn provided(&mut self, bid: u16, len: usize) -> Option<Self::Provided>

impl SubmitOps for &mut Driver

fn submit_accept( self, fd: Fd, ) -> impl Future<Output = Result<(RawFd, SockAddr)>> + 'static

fn submit_read<B>( self, fd: Fd, buf: B, ) -> impl Future<Output = (Result<u32>, B)> + 'static

where B: AsMut<[u8]> + Unpin + 'static,

fn submit_send_raw<B>( self, fd: Fd, buf: B, len: usize, ) -> impl Future<Output = (Result<u32>, B)> + 'static

where B: AsRef<[u8]> + Unpin + 'static,

fn submit_sendmsg_raw<P>( self, fd: Fd, packet: P, ) -> impl Future<Output = (Result<u32>, P)> + 'static

where P: SendMsgPacket + Unpin + 'static,

fn submit_recvmsg_raw<P>( self, fd: Fd, packet: P, ) -> impl Future<Output = (Result<u32>, P)> + 'static

where P: RecvMsgPacket + Unpin + 'static,