Trait virtual_fs::AsyncSeek

pub trait AsyncSeek {
    // Required methods
    fn start_seek(self: Pin<&mut Self>, position: SeekFrom) -> Result<(), Error>;
    fn poll_complete(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>,
    ) -> Poll<Result<u64, Error>>;
}

Expand description

Seek bytes asynchronously.

This trait is analogous to the std::io::Seek trait, but integrates with the asynchronous task system. In particular, the start_seek method, unlike Seek::seek, will not block the calling thread.

Utilities for working with AsyncSeek values are provided by AsyncSeekExt.

Required Methods§

fn start_seek(self: Pin<&mut Self>, position: SeekFrom) -> Result<(), Error>

Attempts to seek to an offset, in bytes, in a stream.

A seek beyond the end of a stream is allowed, but behavior is defined by the implementation.

If this function returns successfully, then the job has been submitted. To find out when it completes, call poll_complete.

§Errors

This function can return io::ErrorKind::Other in case there is another seek in progress. To avoid this, it is advisable that any call to start_seek is preceded by a call to poll_complete to ensure all pending seeks have completed.

fn poll_complete( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<u64, Error>>

Waits for a seek operation to complete.

If the seek operation completed successfully, this method returns the new position from the start of the stream. That position can be used later with SeekFrom::Start. Repeatedly calling this function without calling start_seek might return the same result.

§Errors

Seeking to a negative offset is considered an error.

Implementations on Foreign Types§

impl<P> AsyncSeek for Pin<P>
where P: DerefMut + Unpin, <P as Deref>::Target: AsyncSeek,

fn start_seek(self: Pin<&mut Pin<P>>, pos: SeekFrom) -> Result<(), Error>

fn poll_complete( self: Pin<&mut Pin<P>>, cx: &mut Context<'_>, ) -> Poll<Result<u64, Error>>

impl<T> AsyncSeek for &mut T
where T: AsyncSeek + Unpin + ?Sized,

fn start_seek(self: Pin<&mut &mut T>, pos: SeekFrom) -> Result<(), Error>

fn poll_complete( self: Pin<&mut &mut T>, cx: &mut Context<'_>, ) -> Poll<Result<u64, Error>>

impl<T> AsyncSeek for Box<T>
where T: AsyncSeek + Unpin + ?Sized,

fn start_seek(self: Pin<&mut Box<T>>, pos: SeekFrom) -> Result<(), Error>

fn poll_complete( self: Pin<&mut Box<T>>, cx: &mut Context<'_>, ) -> Poll<Result<u64, Error>>

impl<T> AsyncSeek for Cursor<T>
where T: AsRef<[u8]> + Unpin,

fn start_seek(self: Pin<&mut Cursor<T>>, pos: SeekFrom) -> Result<(), Error>

fn poll_complete( self: Pin<&mut Cursor<T>>, _: &mut Context<'_>, ) -> Poll<Result<u64, Error>>

Implementors§

impl AsyncSeek for ArcBoxFile

impl AsyncSeek for BufferFile

impl AsyncSeek for CombineFile

impl AsyncSeek for CopyOnWriteFile

impl AsyncSeek for DualWriteFile

impl AsyncSeek for virtual_fs::host_fs::File

impl AsyncSeek for virtual_fs::host_fs::Stderr

impl AsyncSeek for virtual_fs::host_fs::Stdin

impl AsyncSeek for virtual_fs::host_fs::Stdout

impl AsyncSeek for FileHandle

impl AsyncSeek for virtual_fs::mem_fs::stdio::Stderr

impl AsyncSeek for virtual_fs::mem_fs::stdio::Stdin

impl AsyncSeek for virtual_fs::mem_fs::stdio::Stdout

impl AsyncSeek for NullFile

impl AsyncSeek for Pipe

impl AsyncSeek for PipeRx

impl AsyncSeek for PipeTx

impl AsyncSeek for RandomFile

impl AsyncSeek for DeviceFile

impl AsyncSeek for StaticFile

impl AsyncSeek for WebCFile

impl AsyncSeek for TraceFile

impl AsyncSeek for virtual_fs::webc_volume_fs::File

impl AsyncSeek for ZeroFile

impl AsyncSeek for Empty

impl AsyncSeek for File

impl<R> AsyncSeek for BufReader<R>
where R: AsyncRead + AsyncSeek,

Seeks to an offset, in bytes, in the underlying reader.

The position used for seeking with SeekFrom::Current(_) is the position the underlying reader would be at if the BufReader had no internal buffer.

Seeking always discards the internal buffer, even if the seek position would otherwise fall within it. This guarantees that calling .into_inner() immediately after a seek yields the underlying reader at the same position.

See AsyncSeek for more details.

Note: In the edge case where you’re seeking with SeekFrom::Current(n) where n minus the internal buffer length overflows an i64, two seeks will be performed instead of one. If the second seek returns Err, the underlying reader will be left at the same position it would have if you called seek with SeekFrom::Current(0).

impl<RW> AsyncSeek for BufStream<RW>
where RW: AsyncRead + AsyncWrite + AsyncSeek,

Seek to an offset, in bytes, in the underlying stream.

The position used for seeking with SeekFrom::Current(_) is the position the underlying stream would be at if the BufStream had no internal buffer.

Seeking always discards the internal buffer, even if the seek position would otherwise fall within it. This guarantees that calling .into_inner() immediately after a seek yields the underlying reader at the same position.

See AsyncSeek for more details.

Note: In the edge case where you’re seeking with SeekFrom::Current(n) where n minus the internal buffer length overflows an i64, two seeks will be performed instead of one. If the second seek returns Err, the underlying reader will be left at the same position it would have if you called seek with SeekFrom::Current(0).

impl<T> AsyncSeek for ArcFile<T>
where T: VirtualFile + Send + Sync + 'static,

impl<W> AsyncSeek for BufWriter<W>
where W: AsyncWrite + AsyncSeek,

Seek to the offset, in bytes, in the underlying writer.

Seeking always writes out the internal buffer before seeking.