Struct nix::sys::aio::AioRead

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

Asynchronously reads from a file descriptor into a buffer

References

aio_read

Examples

const INITIAL: &[u8] = b"abcdef123456";
const LEN: usize = 4;
let mut rbuf = vec![0; LEN];
let mut f = tempfile().unwrap();
f.write_all(INITIAL).unwrap();
{
    let mut aior = Box::pin(
        AioRead::new(
            f.as_raw_fd(),
            2,   //offset
            &mut rbuf,
            0,   //priority
            SigevNotify::SigevNone
        )
    );
    aior.as_mut().submit().unwrap();
    while (aior.as_mut().error() == Err(Errno::EINPROGRESS)) {
        thread::sleep(time::Duration::from_millis(10));
    }
    assert_eq!(aior.as_mut().aio_return().unwrap(), LEN);
}
assert_eq!(rbuf, b"cdef");

Implementations

impl<'a> AioRead<'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 mut [u8],
    prio: i32,
    sigev_notify: SigevNotify
) -> Self

Create a new AioRead, placing the data in a mutable slice.

Arguments

• fd: File descriptor to read from
• offs: File offset
• buf: A memory buffer. It must outlive the AioRead.
• 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 AioRead<'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 AioRead<'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 AioRead<'a>

fn as_ref(&self) -> &aiocb

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

impl<'a> Debug for AioRead<'a>

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

Formats the value using the given formatter.