Struct spectrusty_formats::tap::TapChunkReader

pub struct TapChunkReader<R> {
    pub checksum: u8,
    /* private fields */
}

Implements a Reader of TAP chunks data.

Implements reader that reads only up to the size of the current TAP chunk.

Fields

checksum: u8

The checksum is being updated when reading via Read methods from a TapChunkReader.

Implementations

impl<R> TapChunkReader<R>

pub fn into_inner(self) -> R

Returns the wrapped reader.

pub fn get_ref(&self) -> &Take<R>

Returns a reference to the chunk’s Take reader.

pub fn get_mut(&mut self) -> &mut Take<R>

Returns a mutable reference to the chunk’s Take reader.

Examples found in repository

src/tap/read.rs (line 355)

    fn next(&mut self) -> Option<Self::Item> {
        let info = match self.inner.next_chunk() {
            Ok(None) => return None,
            Ok(_) => TapChunkInfo::try_from(self.inner.get_mut()),
            Err(e) => return Some(Err(e))
        };
        Some(info)
    }

src/mdr.rs (line 789)

    fn file_from_tap_reader<R: Read + Seek>(&mut self, rd: &mut TapChunkReader<R>) -> io::Result<u8> {
        if rd.chunk_limit() == 0 {
            rd.next_chunk()?;
        }
        let header = if let TapChunkInfo::Head(header) = TapChunkInfo::try_from(rd.get_mut())? {
            header
        }
        else {
            return Err(io::Error::new(io::ErrorKind::InvalidData, "not a TAP header"))
        };
        if let Some(chunk_size) = rd.next_chunk()? {
            if chunk_size < 2 || header.length != chunk_size - 2 {
                return Err(io::Error::new(io::ErrorKind::InvalidData, "not a TAP block"))
            }
            let mut flag = 0u8;
            rd.read_exact(slice::from_mut(&mut flag))?;
            if flag != DATA_BLOCK_FLAG {
                return Err(io::Error::new(io::ErrorKind::InvalidData, "invalid TAP block flag"))
            }
        }
        else {
            return Err(io::Error::new(io::ErrorKind::InvalidData, "missing TAP chunk"))
        }
        let fbheader = MdrFileHeader::from(&header).into_array();
        let hdrd = io::Cursor::new(fbheader).chain(rd.take(header.length as u64));
        let res = self.store_file(header.name, true, hdrd)?;
        {
            let mut checksum = 0u8;
            let res = rd.read_exact(slice::from_mut(&mut checksum));
            if res.is_err() || rd.checksum != 0 {
                self.erase_file(header.name);
                return Err(io::Error::new(io::ErrorKind::InvalidData, "TAP block checksum error"))
            }
        }
        Ok(res)
    }

impl<R: Read + Seek> TapChunkReader<R>

pub fn try_from_current(rd: R, chunk_no: u32) -> Result<Self>

Creates a new instance of TapChunkReader from the reader with an assumption that the next two bytes read from it will form the next chunk header.

chunk_no should be the chunk number of the previous chunk.

pub fn try_clone_mut(&mut self) -> Result<TapChunkReaderMut<'_, R>>

Creates a clone of self but with a mutable reference to the underlying reader.

Returns a guard that, when dropped, will try to restore the original position of the reader. However to check if it succeeded it’s better to use TapChunkReaderMut::done method directly on the guard which returns a result from the seek operation.

Trait Implementations

impl<R> AsMut<TapChunkReader<R>> for TapChunkPulseIter<R>

fn as_mut(&mut self) -> &mut TapChunkReader<R>

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

impl<T, R> AsMut<TapChunkReader<R>> for TapReadInfoIter<T>where
    T: Deref<Target = TapChunkReader<R>> + DerefMut,

fn as_mut(&mut self) -> &mut TapChunkReader<R>

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

impl<R> AsRef<TapChunkReader<R>> for TapChunkPulseIter<R>

fn as_ref(&self) -> &TapChunkReader<R>

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

impl<T, R> AsRef<TapChunkReader<R>> for TapReadInfoIter<T>where
    T: Deref<Target = TapChunkReader<R>>,

fn as_ref(&self) -> &TapChunkReader<R>

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

impl<R: Debug> Debug for TapChunkReader<R>

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

Formats the value using the given formatter.

impl<R: Read + Seek> From<R> for TapChunkReader<R>

fn from(rd: R) -> Self

Converts to this type from the input type.

impl<R: Read + Seek> From<TapChunkReader<R>> for TapChunkPulseIter<R>

fn from(rd: TapChunkReader<R>) -> Self

Converts to this type from the input type.

impl<R: Read> Read for TapChunkReader<R>

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

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

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

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

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_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<R: Read + Seek> TapChunkRead for TapChunkReader<R>

fn next_chunk(&mut self) -> Result<Option<u16>>

Also clears TapChunkReader::checksum.

fn chunk_no(&self) -> u32

Returns this chunk’s number.

fn chunk_limit(&self) -> u16

Returns this chunk’s remaining bytes to be read.

fn rewind(&mut self)

Repositions the inner reader to the start of a file and sets the inner limit to 0. To read the first chunk you need to call TapChunkRead::next_chunk first.

fn skip_chunks(&mut self, skip: u32) -> Result<Option<u16>>

Forwards the inner reader to the position of a next skip + 1 TAP chunks. Returns Ok(None) if the end of the file has been reached. On success returns Ok(size) in bytes of the next TAP chunk and limits the inner Take reader to that size.

fn rewind_nth_chunk(&mut self, chunk_no: u32) -> Result<bool>

Rewinds or forwards the tape to the nth chunk. Returns Ok(true) if the nth chunk exists. Otherwise returns Ok(false) and leaves the seek position at the end of the tape.

fn forward_chunk(&mut self) -> Result<bool>

Forwards the tape to the next chunk. Returns Ok(true) if the forwarded to chunk exists. Otherwise returns Ok(false) and leaves the seek position at the end of the tape.

fn rewind_prev_chunk(&mut self) -> Result<u32>

Rewinds the tape to the beginning of the previous chunk. Returns Ok(chunk_no).

fn rewind_chunk(&mut self) -> Result<u32>

Rewinds the tape to the beginning of the current chunk. Returns Ok(chunk_no).

impl<'a, R: Seek> TryFrom<TapChunkReader<&'a mut R>> for TapChunkReaderMut<'a, R>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(reader: TapChunkReader<&'a mut R>) -> Result<Self>

Performs the conversion.