Struct btlib::sectored_buf::SectoredBuf

pub struct SectoredBuf<T> { /* private fields */ }

A stream which buffers writes and read such that the inner stream only sees reads and writes of sector length buffers.

Implementations

impl<T: Sectored + Read + Seek + AsRef<BlockMeta>> SectoredBuf<T>

pub fn new(inner: T) -> Result<SectoredBuf<T>>

Creates a new SectoredBuf which buffers the given stream.

impl<T: Read + Write + Seek + MetaAccess> SectoredBuf<T>

pub fn update_size(inner: &mut T, size: usize) -> Result<()>

Updates the size stored in the metadata of the block.

impl<T> SectoredBuf<T>

pub fn get_ref(&self) -> &T

Returns a reference to the inner stream.

pub fn get_mut(&mut self) -> &mut T

Returns a mutable reference to the inner stream.

impl<T: Seek + Read + AsRef<BlockMeta>> SectoredBuf<T>

pub fn get_buf(&self, offset: u64, size: u64) -> Result<&[u8]>

Returns a slice of the internal buffer that starts at the given offset in the inner stream, and which is no longer than the given size. Note that this slice may be shorter than the size parameter if the number of bytes in the internal buffer is less than size.

Trait Implementations

impl<U, T: AsMut<U>> AsMut<U> for SectoredBuf<T>

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

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

impl<U, T: AsRef<U>> AsRef<U> for SectoredBuf<T>

fn as_ref(&self) -> &U

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

impl<T> Decompose<T> for SectoredBuf<T>

fn into_inner(self) -> T

impl<T> Positioned for SectoredBuf<T>

fn pos(&self) -> usize

Returns the position of this stream (byte offset relative to the beginning).

impl<T: Read + Seek + AsRef<BlockMeta>> Read for SectoredBuf<T>

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

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

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

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

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

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

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

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

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

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

Read the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Read the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Selfwhere Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>where Self: Sized,

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

impl<T: Read + Seek + AsRef<BlockMeta>> ReadDual for SectoredBuf<T>

fn read_into<W: Write>(&mut self, write: W, count: usize) -> Result<usize>

impl<T> Sectored for SectoredBuf<T>

fn sector_sz(&self) -> usize

Returns the size of the sector for this stream.

fn sector_sz64(&self) -> u64

Returns the sector size as a u64.

fn assert_sector_sz(&self, actual: usize) -> Result<()>

Returns Err(Error::IncorrectSize) if the given size is not equal to the sector size.

fn assert_at_least_sector_sz(&self, actual: usize) -> Result<()>

Returns Err(Error::IncorrectSize) if the given size is less than the sector size.

fn offset_at(&self, index: u64) -> u64

Returns the offset (in bytes) from the beginning of this stream that the given 0-based sector index corresponds to.

impl<T: Seek + Read + Write + MetaAccess> Seek for SectoredBuf<T>

fn seek(&mut self, seek_from: SeekFrom) -> Result<u64>

Seek to an offset, in bytes, in a stream.

fn rewind(&mut self) -> Result<(), Error>

Rewind to the beginning of a stream.

fn stream_len(&mut self) -> Result<u64, Error>

🔬This is a nightly-only experimental API. (seek_stream_len)

Returns the length of this stream (in bytes).

fn stream_position(&mut self) -> Result<u64, Error>

Returns the current seek position from the start of the stream.

impl<T: AsRef<BlockMeta>> Size for SectoredBuf<T>

fn size(&self) -> Result<Option<u64>>

Returns the size of the block, which the value stored in the block’s metadata, not the length of the inner stream.

impl<T> Split<SectoredBuf<&'static [u8]>, T> for SectoredBuf<T>

fn split(self) -> (SectoredBuf<&'static [u8]>, T)

fn combine(left: SectoredBuf<&'static [u8]>, right: T) -> Self

impl<T: Read + Seek + AsRef<BlockMeta>> TrySeek for SectoredBuf<T>

fn try_seek(&mut self, seek_from: SeekFrom) -> Result<()>

Attempts to seek to the given offset from the start of the stream.

impl<T: Seek + Read + Write + MetaAccess> Write for SectoredBuf<T>

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

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

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

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

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Selfwhere Self: Sized,

Creates a “by reference” adapter for this instance of Write.

impl<T: Read + Write + Seek + MetaAccess> WriteDual for SectoredBuf<T>

fn write_from<R: Read>(&mut self, read: R, count: usize) -> Result<usize>

impl<T: Read + Write + Seek + MetaAccess> ZeroExtendable for SectoredBuf<T>

fn zero_extend(&mut self, num_zeros: u64) -> Result<()>

Extends this stream with the given number of zero bytes. The position of the stream must be unchanged when this method returns successfully. The state of the stream in the case of an error is undefined.