Struct PulseDecodeWriter 

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

Provides a decoder of TAPE T-state pulse intervals.

The timing of the pulses should match those produced by ZX Spectrum’s ROM loading routines.

After invoking PulseDecodeWriter::end or PulseDecodeWriter::new PulseDecodeWriter expects a data transfer which consists of:

• lead pulses followed by
• two synchronization pulses followed by
• data pulses

Provide pulse iterators to PulseDecodeWriter::write_decoded_pulses method to write interpreted data to the underlying writer.

Best used with tap utilities.

Implementations

impl<W> PulseDecodeWriter<W>

pub fn reset(&mut self)

Resets the state of the PulseDecodeWriter to Idle, discarding any partially received byte.

The information about the number of bytes written so far is lost.

pub fn is_idle(&self) -> bool

Returns true if the state is PulseDecodeState::Idle.

pub fn into_inner(self) -> W

Returns the underlying writer.

pub fn state(&self) -> PulseDecodeState

Returns a reference to the current state.

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

Returns a mutable reference to the inner writer.

pub fn get_ref(&self) -> &W

Returns a shared reference to the inner writer.

pub fn data_size(&self) -> Option<NonZeroU32>

Returns a number of bytes written during current data transfer if a data transfer is in progress.

pub fn with_state(self, state: PulseDecodeState) -> Self

Allows to manually assign state. Can be used to deserialize PulseDecodeWriter.

impl<W: Write> PulseDecodeWriter<W>

pub fn new(wr: W) -> Self

Creates a new PulseDecodeWriter from a given Writer.

pub fn end(&mut self) -> Result<Option<NonZeroU32>>

Optionally writes a partially received data byte and ensures the state of PulseDecodeWriter is Idle.

After calling this method, regardless of the return value, the state is changed to PulseDecodeState::Idle.

Returns Ok(None) if there was no data written in the current transfer.

Returns Ok(Some(size)) if data has been written, providing the number of written bytes.

In the case of std::io::Error the information about the number of bytes written is lost.

pub fn write_decoded_pulses<I>(&mut self, iter: I) -> Result<Option<NonZeroU32>>

where I: Iterator<Item = NonZeroU32>,

Interprets pulse intervals from the provided pulse iterator as data bytes, writing them to the underlying writer.

The pulse iterator is expected to provide only a fragment of pulses needed for the complete transfer such as an iterator returned from MicOut::mic_out_pulse_iter. Providing an empty iterator is equivalent to calling PulseDecodeWriter::end thus ending the current transfer in progress if there is any.

Returns Ok(None) if there was no data or more pulses are being expected.

Returns Ok(Some(size)) if data block has been written, providing the number of written bytes. In this instance, there can still be some pulses left in the iterator, e.g. for the next incoming transfer.

In the case of std::io::Error the information about the number of bytes written is lost.

Trait Implementations

impl<W: Debug> Debug for PulseDecodeWriter<W>

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

Formats the value using the given formatter.