[−][src]Trait system_interface::fs::FileIoExt

pub trait FileIoExt {
    fn advise(&self, offset: u64, len: u64, advice: Advice) -> Result<()>;
    fn read(&self, buf: &mut [u8]) -> Result<usize>;
    fn read_exact(&self, buf: &mut [u8]) -> Result<()>;
    fn read_at(&self, buf: &mut [u8], offset: u64) -> Result<usize>;
    fn read_exact_at(&self, buf: &mut [u8], offset: u64) -> Result<()>;
    fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize>;
    fn read_to_end(&self, buf: &mut Vec<u8>) -> Result<usize>;
    fn read_to_string(&self, buf: &mut String) -> Result<usize>;
    fn bytes(self) -> Bytes<File>;
    fn chain<R: Read>(self, next: R) -> Chain<File, R>;
    fn take(self, limit: u64) -> Take<File>;
    fn write(&self, buf: &[u8]) -> Result<usize>;
    fn write_all(&self, buf: &[u8]) -> Result<()>;
    fn write_at(&self, buf: &[u8], offset: u64) -> Result<usize>;
    fn write_all_at(&self, buf: &[u8], offset: u64) -> Result<()>;
    fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> Result<usize>;
    fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<()>;
    fn flush(&self) -> Result<()>;
    fn seek(&self, pos: SeekFrom) -> Result<u64>;
    fn stream_position(&self) -> Result<u64>;

    fn read_exact_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> Result<()> { ... }
    fn read_vectored_at(
        &self, 
        bufs: &mut [IoSliceMut<'_>], 
        offset: u64
    ) -> Result<usize> { ... }
    fn read_exact_vectored_at(
        &self, 
        bufs: &mut [IoSliceMut<'_>], 
        offset: u64
    ) -> Result<()> { ... }
    fn is_read_vectored_at(&self) -> bool { ... }
    fn write_all_vectored(&self, bufs: &mut [IoSlice<'_>]) -> Result<()> { ... }
    fn write_vectored_at(
        &self, 
        bufs: &[IoSlice<'_>], 
        offset: u64
    ) -> Result<usize> { ... }
    fn write_all_vectored_at(
        &self, 
        bufs: &mut [IoSlice<'_>], 
        offset: u64
    ) -> Result<()> { ... }
    fn is_write_vectored_at(&self) -> bool { ... }
}

extension trait for std::fs::File and cap_std::fs::File.

Required methods

`fn advise(&self, offset: u64, len: u64, advice: Advice) -> Result<()>`

Announce the expected access pattern of the data at the given offset.

`fn read(&self, buf: &mut [u8]) -> Result<usize>`

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

This is similar to std::io::Read::read, except it takes self by immutable reference since the entire side effect is I/O.

`fn read_exact(&self, buf: &mut [u8]) -> Result<()>`

Read the exact number of bytes required to fill buf.

This is similar to std::io::Read::read_exact, except it takes self by immutable reference since the entire side effect is I/O.

`fn read_at(&self, buf: &mut [u8], offset: u64) -> Result<usize>`

Reads a number of bytes starting from a given offset.

This is similar to std::os::unix::fs::FileExt::read_at, except it takes self by immutable reference since the entire side effect is I/O, and it's supported on non-Unix platforms including Windows.

`fn read_exact_at(&self, buf: &mut [u8], offset: u64) -> Result<()>`

Reads the exact number of byte required to fill buf from the given offset.

This is similar to std::os::unix::fs::FileExt::read_exact_at, except it takes self by immutable reference since the entire side effect is I/O, and it's supported on non-Unix platforms including Windows.

`fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize>`

Like read, except that it reads into a slice of buffers.

This is similar to std::io::Read::read_vectored, except it takes self by immutable reference since the entire side effect is I/O.

`fn read_to_end(&self, buf: &mut Vec<u8>) -> Result<usize>`

Read all bytes until EOF in this source, placing them into buf.

This is similar to std::io::Read::read_to_end, except it takes self by immutable reference since the entire side effect is I/O.

`fn read_to_string(&self, buf: &mut String) -> Result<usize>`

Read all bytes until EOF in this source, appending them to buf.

This is similar to std::io::Read::read_to_string, except it takes self by immutable reference since the entire side effect is I/O.

`fn bytes(self) -> Bytes<File>`

Transforms this FileIoExt instance to an Iterator over its bytes.

This is similar to Read::bytes, except it returns a io::Bytes<fs::File> instead of an io::Bytes::<Self>.

`fn chain<R: Read>(self, next: R) -> Chain<File, R>`

Creates an adaptor which will chain this stream with another.

This is similar to Read::chain, except it returns a io::Chain<fs::File, R> instead of an io::Chain::<Self, R>.

`fn take(self, limit: u64) -> Take<File>`

Creates an adaptor which will read at most limit bytes from it.

This is similar to Read::take, except it returns a io::Take<fs::File> instead of an io::Take::<Self>.

`fn write(&self, buf: &[u8]) -> Result<usize>`

Write a buffer into this writer, returning how many bytes were written.

This is similar to std::io::Write::write, except it takes self by immutable reference since the entire side effect is I/O.

`fn write_all(&self, buf: &[u8]) -> Result<()>`

Attempts to write an entire buffer into this writer.

This is similar to std::io::Write::write_all, except it takes self by immutable reference since the entire side effect is I/O.

`fn write_at(&self, buf: &[u8], offset: u64) -> Result<usize>`

Writes a number of bytes starting from a given offset.

This is similar to std::os::unix::fs::FileExt::write_at, except it takes self by immutable reference since the entire side effect is I/O, and it's supported on non-Unix platforms including Windows.

`fn write_all_at(&self, buf: &[u8], offset: u64) -> Result<()>`

Attempts to write an entire buffer starting from a given offset.

This is similar to std::os::unix::fs::FileExt::write_all_at, except it takes self by immutable reference since the entire side effect is I/O, and it's supported on non-Unix platforms including Windows.