Struct NibSlice 

pub struct NibSlice<'a> { /* private fields */ }

A const slice (&[u4]) over nibbles (4-bit values)

Internally, it operates on an array of bytes, and interprets them as pairs of nibbles. This is intended to allow use of a NibSlice to examine binary structures that are composed of nibbles.

For each byte, the nibble composed of the lower bits (mask = 0x0f) is considered to come before the nibble composed of the higher bits (mask = 0xf0).

Implementations

impl<'a> NibSlice<'a>

pub fn from_bytes_exclude(inner: &'a [u8], exclude: Exclude) -> Self

Create a NibSlice from a slice of bytes and whether to exclude either end of the slice

pub fn from_bytes_skip_last(inner: &'a [u8]) -> Self

Create a NibSlice from a slice of bytes, excluding the last nibble in the slice

pub fn from_bytes(inner: &'a [u8]) -> Self

Create a NibSlice from a slice of bytes, including all nibbles in the given bytes

The resulting NibSlice will have .len() equal to 2 * inner.len().

pub fn len(&self) -> usize

The number of nibbles in the NibSlice

pub fn split_at(&self, offset: usize) -> (NibSlice<'a>, NibSlice<'a>)

Split the NibSlice into 2 NibSlices at the nibble offset given

The nibble at offset is included in the second slice returned

pub fn index<S: SliceIndex<'a>>(&self, idx: S) -> S::Output

Index, using various ranges, a NibSlice into NibSlices that are sub-slices

Examples

use quartet::{NibSlice, Exclude};
let ns = NibSlice::from_bytes_exclude(&[0x12, 0x34, 0x56], Exclude::Both);
let n = ns.index(2..4);

assert_eq!(n, NibSlice::from_bytes(&[0x45]));

pub fn get<S: SliceIndex<'a>>(&self, idx: S) -> Option<S::Output>

Get the NibSlice refered to by the indexing value, or return None if index is out of range

pub fn nibble(&self) -> u8

If the slice refers to a single nibble, return that nibble as a byte. Panic if slice does not have exactly one nibble

Examples

use quartet::{NibSlice, Exclude};

let orig_s = NibSlice::from_bytes_exclude(&[0x02, 0x34], Exclude::First);
let nib_s = orig_s.index(..1);
assert_eq!(nib_s.len(), 1);

let nib = nib_s.nibble();

assert_eq!(nib, 0x2);

pub fn try_nibble(&self) -> Option<u8>

If the slice refers to a single nibble, return that nibble as a byte. Return None if the slice does not have exactly one nibble

Examples

use quartet::{NibSlice, Exclude};
let orig_s = NibSlice::from_bytes_exclude(&[0x02, 0x34], Exclude::First);
let nib_s = orig_s.index(..1);
let nib = nib_s.try_nibble();
assert_eq!(nib, Some(0x2));

// more than 1 nibble
assert_eq!(orig_s.index(1..3).try_nibble(), None);

pub fn iter(&self) -> Iter<'a>

Create an iterator over the NibSlice, where each item is a nibble

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

Decompose the NibSlice into byte-oriented parts

The first and last members of the tuple are the non-byte aligned nibbles optionally at the start and end of the NibSlice. The middle member is the byte-aligned nibbles organized into bytes

Trait Implementations

impl<'a> Clone for NibSlice<'a>

fn clone(&self) -> NibSlice<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for NibSlice<'a>

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

Formats the value using the given formatter.

impl<'a> Display for NibSlice<'a>

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

Formats the value using the given formatter.

impl PartialEq<NibSlice<'_>> for NibSlice<'_>

fn eq(&self, other: &NibSlice<'_>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Copy for NibSlice<'a>

impl Eq for NibSlice<'_>