Enum Tap 

pub enum Tap<F> {
    Reader(TapChunkPulseIter<F>),
    Writer(TapChunkWriter<F>),
}

An enum with two variants, one for reading and the other for writing to the same TAP file.

The F can be anything that implements: Read + Write + Seek.

Variants

Reader(TapChunkPulseIter<F>)

Writer(TapChunkWriter<F>)

Implementations

impl<F: Write + Read + Seek> Tap<F>

pub fn new_reader(file: F) -> Self

Returns a Tap::Reader variant.

pub fn try_new_writer(file: F) -> Result<Self>

Returns a Tap::Writer variant on success.

pub fn reader_mut(&mut self) -> Option<&mut TapChunkPulseIter<F>>

Returns a mutable reference to the pulse iterator if the current variant of self is Tap::Reader.

pub fn writer_mut(&mut self) -> Option<&mut TapChunkWriter<F>>

Returns a mutable reference to the tap chunk writer if the current variant of self is Tap::Writer.

pub fn reader_ref(&self) -> Option<&TapChunkPulseIter<F>>

Returns a reference to the pulse iterator if the current variant of self is Tap::Reader.

pub fn writer_ref(&self) -> Option<&TapChunkWriter<F>>

Returns a reference to the tap chunk writer if the current variant of self is Tap::Writer.

pub fn is_reader(&self) -> bool

Returns true if self is a Tap::Reader.

pub fn is_writer(&self) -> bool

Returns true if self is a Tap::Writer.

pub fn try_into_reader(self) -> Result<Self>

Transforms the provided Tap into the Tap::Reader on success.

The cursor position of the reader is set to the beginning of a file.

If self is a Tap::Writer this method ensures that the chunk being currently written is comitted thus ensuring the integrity of the TAP file and also calls the Write::flush on the file before transforming it.

pub fn try_into_writer(self) -> Result<Self>

Transforms the provided Tap into the Tap::Writer on success.

The cursor position of the writer is set to the end of a file.

If self is already a Tap::Writer this method ensures that the chunk being currently written is comitted thus ensuring the integrity of the TAP file and also calls the Write::flush on the file before transforming it.

pub fn try_into_file(self) -> Result<F>

Returns the unwrapped file on success.

If self is a Tap::Writer this method ensures that the chunk being currently written is comitted thus ensuring the integrity of the TAP file and also calls the Write::flush on the file before returning it.

pub fn try_reader_mut(&mut self) -> Result<TapChunkReaderMut<'_, F>>

Returns a clone of TapChunkReader with a mutable reference to the file under the guard that ensures the position of the underlying file is set back to where it was before this method was called when the guard goes out of scope.

pub fn rewind(&mut self) -> bool

Conditionally rewinds a tape if its variant is Tap::Reader. In this instance returns true. Otherwise returns false.

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

Conditionally forwards a tape to the next chunk if its variant is Tap::Reader. In this instance returns Ok(Some(was_next_chunk)). Otherwise returns Ok(None).

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

Conditionally rewinds a tape to the previous chunk if its variant is Tap::Reader. In this instance returns Ok(Some(chunk_no)). Otherwise returns Ok(None).

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

Conditionally rewinds a tape to the beginning of the current chunk if its variant is Tap::Reader. In this instance returns Ok(Some(chunk_no)). Otherwise returns Ok(None).

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

Conditionally rewinds or forwards a tape to the nth chunk if its variant is Tap::Reader. In this instance returns Ok(Some(was_a_chunk)). Otherwise returns Ok(None).

Trait Implementations

impl<F> Debug for Tap<F>

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

Formats the value using the given formatter.