Struct spectrusty_formats::tap::TapChunkReaderMut

pub struct TapChunkReaderMut<'a, R: Seek> { /* private fields */ }

A guard returned by TapChunkReader::try_clone_mut.

This struct dereferences to TapChunkReader.

Implementations

impl<'a, R: Seek> TapChunkReaderMut<'a, R>

pub fn done(self) -> Result<u64>

Tries to restore the original reader position before dropping self.

Methods from Deref<Target = TapChunkReader<&'a mut R>>

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)
    }

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<'a, R: Debug + Seek> Debug for TapChunkReaderMut<'a, R>

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

Formats the value using the given formatter.

impl<'a, R: Seek> Deref for TapChunkReaderMut<'a, R>

type Target = TapChunkReader<&'a mut R>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, R: Seek> DerefMut for TapChunkReaderMut<'a, R>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a, R: Seek> Drop for TapChunkReaderMut<'a, R>

fn drop(&mut self)

Executes the destructor for this type.

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.