Struct spectrusty_formats::tap::TapChunk

pub struct TapChunk<T> { /* private fields */ }

The TAP chunk.

Provides helper methods to interpret the underlying bytes as one of the TAP blocks. This should usually be a Header or a data block.

Anything that implements AsRef<[u8]> can be used as T (e.g. &[u8] or Vec<u8>).

Instances of TapChunk can be created using From/Into interface or via TapChunkIter.

Implementations

impl<T> TapChunk<T>

pub fn into_inner(self) -> T

Returns the underlying bytes container.

Examples found in repository

src/tap.rs (line 817)

    pub fn into_pulse_iter(self) -> ReadEncPulseIter<Cursor<T>> {
        ReadEncPulseIter::new(Cursor::new(self.into_inner()))
    }

    /// Creates a new TapChunk with a specified storage, possibly cloning the data
    /// unless the target storage can be converted to without cloning,
    /// e.g. `Vec<u8> <=> Box<[u8]>`.
    pub fn with_storage<D>(self) -> TapChunk<D>
    where D: From<T> + AsRef<[u8]>
    {
        let data = D::from(self.into_inner());
        TapChunk::<D>::from(data)
    }

impl<T> TapChunk<T>where
    T: AsRef<[u8]>,

pub fn info(&self) -> Result<TapChunkInfo>

Attempts to create an instance of TapChunkInfo from underlying data.

Examples found in repository

src/tap.rs (line 414)

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self.info() {
            Ok(info) => info.fmt(f),
            Err(e) => write!(f, "{}", e)
        }
    }

pub fn checksum(&self) -> u8

Calculates bit-xor checksum of underlying data.

pub fn is_head(&self) -> bool

Checks if this TAP chunk is a Header block.

Examples found in repository

src/tap.rs (line 734)

    pub fn name(&self) -> Option<Cow<'_,str>> {
        if self.is_head() {
            Some(String::from_utf8_lossy(&self.data.as_ref()[2..12]))
        }
        else {
            None
        }
    }

    /// Returns a reference to the underlying data block only if the underlying bytes represents the data block.
    ///
    /// The provided reference does not include block flag and checksum bytes.
    pub fn data(&self) -> Option<&[u8]> {
        let data = self.data.as_ref();
        if self.is_data() {
            Some(&data[1..data.len()-1])
        }
        else {
            None
        }
    }

    /// Returns a length in bytes of the next chunk's data block only if the underlying bytes represents
    /// the [Header] block.
    ///
    /// The provided length does not include block flag and checksum bytes.
    pub fn data_block_len(&self) -> Option<u16> {
        if self.is_head() {
            if let [lo, hi] = self.data.as_ref()[12..14] {
                return Some(u16::from_le_bytes([lo, hi]))
            }
        }
        None
    }
    /// Returns a starting address only if the underlying bytes represents the [Header] block.
    ///
    /// Depending of the type of this header it may be either a starting address of [BlockType::Code]
    /// or starting line of [BlockType::Program].
    pub fn start(&self) -> Option<u16> {
        if self.is_head() {
            if let [lo, hi] = self.data.as_ref()[14..16] {
                return Some(u16::from_le_bytes([lo, hi]))
            }
        }
        None
    }

    /// Returns an offset to `VARS` only if the underlying bytes represents the [Header] block.
    ///
    /// Only valid for headers with [BlockType::Program].
    pub fn vars(&self) -> Option<u16> {
        if self.is_head() {
            if let [lo, hi] = self.data.as_ref()[16..18] {
                return Some(u16::from_le_bytes([lo, hi]))
            }
        }
        None
    }

    /// Returns an array variable name only if the underlying bytes represents the [Header] block.
    ///
    /// Only valid for headers with [BlockType::CharArray] or [BlockType::NumberArray].
    pub fn array_name(&self) -> Option<char> {
        if self.is_head() {
            return Some(array_name(self.data.as_ref()[15]))
        }
        None
    }

    /// Returns a next chunk's data type only if the underlying bytes represents the [Header] block.
    pub fn block_type(&self) -> Option<BlockType> {
        if self.is_head() {
            return BlockType::try_from(self.data.as_ref()[1]).ok()
        }
        None
    }

pub fn is_data(&self) -> bool

Checks if this TAP chunk is a data block.

Examples found in repository

src/tap.rs (line 747)

    pub fn data(&self) -> Option<&[u8]> {
        let data = self.data.as_ref();
        if self.is_data() {
            Some(&data[1..data.len()-1])
        }
        else {
            None
        }
    }

pub fn is_valid(&self) -> bool

Checks if this TAP chunk is a valid data or Header block.

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

Validates if this TAP chunk is a valid data or Header block returning self on success.

pub fn validate(&self) -> Result<()>

Validates if this TAP chunk is a valid data or Header block.

Examples found in repository

src/tap.rs (line 706)

    pub fn is_valid(&self) -> bool {
        self.validate().is_ok()
    }

    /// Validates if this *TAP* chunk is a valid data or [Header] block returning `self` on success.
    pub fn validated(self) -> Result<Self> {
        self.validate().map(|_| self)
    }

pub fn name(&self) -> Option<Cow<'_, str>>

Returns a name if the block is a Header

pub fn data(&self) -> Option<&[u8]>

Returns a reference to the underlying data block only if the underlying bytes represents the data block.

The provided reference does not include block flag and checksum bytes.

pub fn data_block_len(&self) -> Option<u16>

Returns a length in bytes of the next chunk’s data block only if the underlying bytes represents the Header block.

The provided length does not include block flag and checksum bytes.

pub fn start(&self) -> Option<u16>

Returns a starting address only if the underlying bytes represents the Header block.

Depending of the type of this header it may be either a starting address of BlockType::Code or starting line of BlockType::Program.

pub fn vars(&self) -> Option<u16>

Returns an offset to VARS only if the underlying bytes represents the Header block.

Only valid for headers with BlockType::Program.

pub fn array_name(&self) -> Option<char>

Returns an array variable name only if the underlying bytes represents the Header block.

Only valid for headers with BlockType::CharArray or BlockType::NumberArray.

pub fn block_type(&self) -> Option<BlockType>

Returns a next chunk’s data type only if the underlying bytes represents the Header block.

pub fn as_pulse_iter(&self) -> ReadEncPulseIter<Cursor<&[u8]>>

Returns a pulse interval iterator referencing this TAP chunk.

pub fn into_pulse_iter(self) -> ReadEncPulseIter<Cursor<T>>

Converts this TAP chunk into a pulse interval iterator owning this chunk’s data.

pub fn with_storage<D>(self) -> TapChunk<D>where
    D: From<T> + AsRef<[u8]>,

Creates a new TapChunk with a specified storage, possibly cloning the data unless the target storage can be converted to without cloning, e.g. Vec<u8> <=> Box<[u8]>.

Trait Implementations

impl<T> AsMut<[u8]> for TapChunk<T>where
    T: AsMut<[u8]>,

fn as_mut(&mut self) -> &mut [u8]

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

impl<T> AsRef<[u8]> for TapChunk<T>where
    T: AsRef<[u8]>,

fn as_ref(&self) -> &[u8]

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

impl<T: Clone> Clone for TapChunk<T>

fn clone(&self) -> TapChunk<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for TapChunk<T>

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

Formats the value using the given formatter.

impl<T> Display for TapChunk<T>where
    T: AsRef<[u8]>,

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

Formats the value using the given formatter.

impl<T> From<T> for TapChunk<T>where
    T: AsRef<[u8]>,

fn from(data: T) -> Self

Converts to this type from the input type.

impl<T: Copy> Copy for TapChunk<T>