Struct nix::sys::aio::AioWrite

#[repr(transparent)]
pub struct AioWrite<'a> { /* private fields */ }

Asynchronously writes from a buffer to a file descriptor

References

aio_write

Examples

const WBUF: &[u8] = b"abcdef123456";
let mut f = tempfile().unwrap();
let mut aiow = Box::pin(
    AioWrite::new(
        f.as_raw_fd(),
        2,   //offset
        WBUF,
        0,   //priority
        SigevNotify::SigevNone
    )
);
aiow.as_mut().submit().unwrap();
while (aiow.as_mut().error() == Err(Errno::EINPROGRESS)) {
    thread::sleep(time::Duration::from_millis(10));
}
assert_eq!(aiow.as_mut().aio_return().unwrap(), WBUF.len());

Implementations

impl<'a> AioWrite<'a>

pub fn nbytes(&self) -> usize

Returns the requested length of the aio operation in bytes

This method returns the requested length of the operation. To get the number of bytes actually read or written by a completed operation, use aio_return instead.

pub fn new(
    fd: RawFd,
    offs: off_t,
    buf: &'a [u8],
    prio: i32,
    sigev_notify: SigevNotify
) -> Self

Construct a new AioWrite.

Arguments

• fd: File descriptor to write to
• offs: File offset
• buf: A memory buffer. It must outlive the AioWrite.
• prio: If POSIX Prioritized IO is supported, then the operation will be prioritized at the process’s priority level minus prio
• sigev_notify: Determines how you will be notified of event completion.

pub fn offset(&self) -> off_t

Returns the file offset of the operation.

Trait Implementations

impl<'a> Aio for AioWrite<'a>

type Output = usize

The return type of Aio::aio_return.

fn cancel(self: Pin<&mut Self>) -> Result<AioCancelStat>

Cancels an outstanding AIO request.

fn error(self: Pin<&mut Self>) -> Result<()>

Retrieve error status of an asynchronous operation.

fn fd(&self) -> RawFd

Returns the underlying file descriptor associated with the operation.

fn in_progress(&self) -> bool

Does this operation currently have any in-kernel state?

fn priority(&self) -> i32

Returns the priority of the AioCb

fn set_sigev_notify(&mut self, sev: SigevNotify)

Update the notification settings for an existing AIO operation that has not yet been submitted.

fn sigevent(&self) -> SigEvent

Returns the SigEvent that will be used for notification.

fn aio_return(self: Pin<&mut Self>) -> Result<<Self as Aio>::Output>

Retrieve return status of an asynchronous operation.

fn submit(self: Pin<&mut Self>) -> Result<()>

Actually start the I/O operation.

impl<'a> AsMut<aiocb> for AioWrite<'a>

fn as_mut(&mut self) -> &mut aiocb

Converts this type into a mutable reference of the (usually inferred) input type.

impl<'a> AsRef<aiocb> for AioWrite<'a>

fn as_ref(&self) -> &aiocb

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a> Debug for AioWrite<'a>

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

Formats the value using the given formatter.