Struct spectrusty_formats::tap::TapChunkWriter

pub struct TapChunkWriter<W> { /* private fields */ }

A tool for writing TAP file chunks to byte streams.

Data can be written in one of 3 ways:

• Writing tap chunk data at once with TapChunkWriter::write_header or TapChunkWriter::write_chunk.
• Writing tap chunk data with multiple writes via TapChunkWriter::begin and then TapChunkWriteTran.
• Writing tap chunks from decoded TAPE pulse iterators with TapChunkWriter::write_pulses_as_tap_chunks.

Implementations

impl<W> TapChunkWriter<W>

pub fn into_inner(self) -> PulseDecodeWriter<W>

Returns the underlying pulse decode writer.

pub fn get_mut(&mut self) -> &mut PulseDecodeWriter<W>

Returns a mutable reference to the inner pulse decode writer.

pub fn get_ref(&self) -> &PulseDecodeWriter<W>

Returns a shared reference to the inner pulse decode writer.

impl<W> TapChunkWriter<W>where
    W: Write + Seek,

pub fn try_new(wr: W) -> Result<Self>

Returns a new instance of TapChunkWriter with the given writer on success.

The stream cursor should be positioned where the next chunk will be written.

This method does not write any data, but moves the stream cursor to make room for the next block’s length indicator.

Examples found in repository

src/tap.rs (line 266)

pub fn write_tap<W>(wr: W) -> Result<TapChunkWriter<W>>
    where W: Write + Seek
{
    TapChunkWriter::try_new(wr)
}

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

Flushes the underlying writer, ensuring that all intermediately buffered contents reach their destination (invokes Write::flush).

Examples found in repository

src/tap/write.rs (line 82)

    fn flush(&mut self) -> Result<()> {
        self.writer.flush()
    }

pub fn end_pulse_chunk(&mut self) -> Result<usize>

Forces pending pulse decode data transfer to end.

Returns the number of TAP chunks written.

Examples found in repository

src/tap/write.rs (line 164)

    pub fn write_chunk<D: AsRef<[u8]>>(&mut self, chunk: D) -> Result<usize> {
        let data = chunk.as_ref();
        let size = u16::try_from(data.len()).map_err(|_|
                    Error::new(ErrorKind::InvalidData, "TAP chunk too large."))?;
        let nchunks = self.end_pulse_chunk()?;
        let wr = self.mpwr.get_mut();
        let chunk_head = wr.seek(SeekFrom::Start(self.chunk_head))?;
        debug_assert_eq!(chunk_head, self.chunk_head);
        wr.write_all(&size.to_le_bytes())?;
        wr.write_all(data)?;
        let chunk_start = wr.seek(SeekFrom::Current(LEN_PREFIX_SIZE as i64))?;
        self.chunk_head = chunk_start.checked_sub(LEN_PREFIX_SIZE).unwrap();
        Ok(nchunks + 1)
    }
    /// Creates a transaction allowing for multiple data writes to the same *TAP* chunk.
    ///
    /// Flushes internal [mic pulse writer][PulseDecodeWriter::end].
    ///
    /// Returns a transaction holder, which can be used to write data to the current chunk.
    pub fn begin(&mut self) -> Result<TapChunkWriteTran<'_, W>> {
        let nchunks = self.end_pulse_chunk()?;
        Ok(TapChunkWriteTran { checksum: 0, nchunks, uncommitted: 0, writer: self })
    }

pub fn write_header(&mut self, header: &Header) -> Result<usize>

Writes a provided header as a TAP chunk.

Flushes internal mic pulse writer before proceeding with writing the header.

Returns the number of TAP chunks written.

Examples found in repository

src/mdr.rs (line 767)

    fn file_to_tap_writer<S: AsRef<[u8]>, W: Write + Seek>(
            &self,
            file_name: S,
            wr: &mut TapChunkWriter<W>
        ) -> io::Result<bool>
    {
        let mut sector_iter = self.file_sectors(file_name);
        #[allow(clippy::never_loop)]
        let mut tran = loop {
            if let Some(sector) = sector_iter.next() {
                let sector = sector.unwrap();
                if let Some(header) = sector.tap_header()
                                      .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?
                {
                    wr.write_header(&header)?;
                    let mut tran = wr.begin()?;
                    tran.write_all(slice::from_ref(&DATA_BLOCK_FLAG))?;
                    tran.write_all(&sector.data_record()[HD_SIZE..])?;
                    break tran
                }
            }
            return Ok(false)
        };
        for sector in sector_iter {
            let sector = sector.map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
            let record = sector.data_record();
            tran.write_all(record)?;
        }
        tran.commit(true)?;
        Ok(true)
    }

pub fn write_chunk<D: AsRef<[u8]>>(&mut self, chunk: D) -> Result<usize>

Writes provided data as a TAP chunk.

Flushes internal mic pulse writer before proceeding with writing the data.

Returns the number of TAP chunks written.

Examples found in repository

src/tap/write.rs (line 153)

    pub fn write_header(&mut self, header: &Header) -> Result<usize> {
        self.write_chunk(header.to_tap_chunk())
    }

pub fn begin(&mut self) -> Result<TapChunkWriteTran<'_, W>>

Creates a transaction allowing for multiple data writes to the same TAP chunk.

Flushes internal mic pulse writer.

Returns a transaction holder, which can be used to write data to the current chunk.

Examples found in repository

src/mdr.rs (line 768)

    fn file_to_tap_writer<S: AsRef<[u8]>, W: Write + Seek>(
            &self,
            file_name: S,
            wr: &mut TapChunkWriter<W>
        ) -> io::Result<bool>
    {
        let mut sector_iter = self.file_sectors(file_name);
        #[allow(clippy::never_loop)]
        let mut tran = loop {
            if let Some(sector) = sector_iter.next() {
                let sector = sector.unwrap();
                if let Some(header) = sector.tap_header()
                                      .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?
                {
                    wr.write_header(&header)?;
                    let mut tran = wr.begin()?;
                    tran.write_all(slice::from_ref(&DATA_BLOCK_FLAG))?;
                    tran.write_all(&sector.data_record()[HD_SIZE..])?;
                    break tran
                }
            }
            return Ok(false)
        };
        for sector in sector_iter {
            let sector = sector.map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
            let record = sector.data_record();
            tran.write_all(record)?;
        }
        tran.commit(true)?;
        Ok(true)
    }

pub fn write_pulses_as_tap_chunks<I>(&mut self, iter: I) -> Result<usize>where
    I: Iterator<Item = NonZeroU32>,

Interprets pulse intervals from the provided iterator as bytes and writes them to the underlying writer as TAP chunks.

See PulseDecodeWriter.

Returns the number of TAP chunks written.