Struct IsoCursor 

pub struct IsoCursor<DATA: Seek> {
    pub data: DATA,
    pub sector_size: usize,
}

Available on crate feature sync only.

Represents IsoCursor.

Fields

data: DATA

The data field.

sector_size: usize

The sector_size field.

Implementations

impl<DATA: Seek> IsoCursor<DATA>

pub fn new(data: DATA, sector_size: usize) -> Self

Performs the new operation.

pub fn into_inner(self) -> DATA

Consumes the cursor and returns its underlying data source.

pub fn seek_sector(&mut self, sector: LogicalSector) -> Result<u64>

Performs the seek_sector operation.

impl<DATA: Write + Seek> IsoCursor<DATA>

pub fn pad_align_sector(&mut self) -> Result<LogicalSector>

Advance to the next sector boundary, zero-filling the gap.

The gap is written rather than skipped with a seek: Write + Seek targets are not guaranteed to read unwritten regions back as zeros (reused buffers, block devices with stale data), and readers scan some padding (e.g. the zero record-length terminator at the end of a directory’s sector span). Gaps are always smaller than one sector.

Trait Implementations

impl<DATA: Seek> Debug for IsoCursor<DATA>

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

Formats the value using the given formatter.

impl<DATA: Read + Seek> Read for IsoCursor<DATA>

type Error = <DATA as Read>::Error

Error returned by the underlying source.

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

Read some bytes, returning zero at end of input.

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

Fill buf, retrying interrupted operations.

impl<DATA: Seek> Seek for IsoCursor<DATA>

type Error = <DATA as Seek>::Error

Error returned by the underlying stream.

fn seek(&mut self, pos: SeekFrom) -> Result<u64, Self::Error>

Seek to a new byte position.

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

Return the current byte position.

fn seek_relative(&mut self, offset: i64) -> Result<(), Self::Error>

Seek relative to the current byte position.

impl<DATA: Write + Seek> Write for IsoCursor<DATA>

type Error = <DATA as Write>::Error

Error returned by the underlying destination.

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

Write some bytes.

fn flush(&mut self) -> Result<(), Self::Error>

Flush buffered output.

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

Write all bytes, retrying interrupted operations.