Struct mio_aio::AioCb

pub struct AioCb<'a> { /* fields omitted */ }

A single asynchronous I/O operation

Implementations

impl<'a> AioCb<'a>

Wrapper around nix::sys::aio::AioCb.

Implements mio::Source. After creation, use mio::Source::register to connect to the event loop

pub fn from_fd(fd: RawFd, prio: c_int) -> AioCb<'a>

Wraps nix::sys::aio::AioCb::from_fd.

pub fn from_mut_slice(
    fd: RawFd,
    offs: u64,
    buf: &'a mut [u8],
    prio: c_int,
    opcode: LioOpcode
) -> AioCb<'_>

Wraps nix::sys::aio::from_mut_slice

Not as useful as it sounds, because in typical mio use cases, the compiler can’t guarantee that the slice’s lifetime is respected.

pub fn from_slice(
    fd: RawFd,
    offs: u64,
    buf: &'a [u8],
    prio: c_int,
    opcode: LioOpcode
) -> AioCb<'_>

Wraps nix::sys::aio::from_slice

Mostly useful for writing constant slices

pub fn aio_return(&mut self) -> Result<isize>

Read the final result of the operation

pub fn cancel(&mut self) -> Result<AioCancelStat>

Ask the operating system to cancel the operation

Most file systems on most operating systems don’t actually support cancellation; they’ll just return AIO_NOTCANCELED.

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

Retrieve the status of an in-progress or complete operation.

Not usually needed, since mio_aio always uses kqueue for notification.

pub fn fsync(&mut self, mode: AioFsyncMode) -> Result<()>

Asynchronously fsync a file.

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

Asynchronously read from a file.

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

Asynchronously write to a file.

Trait Implementations

impl<'a> Debug for AioCb<'a>

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

Formats the value using the given formatter.

impl<'a> Source for AioCb<'a>

fn register(
    &mut self,
    registry: &Registry,
    token: Token,
    interests: Interest
) -> Result<()>

Register self with the given Registry instance.

fn reregister(
    &mut self,
    registry: &Registry,
    token: Token,
    interests: Interest
) -> Result<()>

Re-register self with the given Registry instance.

fn deregister(&mut self, _registry: &Registry) -> Result<()>

Deregister self from the given Registry instance.