Struct bitutils2::bin_regex::BinMatch

pub struct BinMatch<'a, T: BitIndexable> { /* private fields */ }

Structure to contain a single BinRegex match.

Examples

use bitutils2::{BinRegex, BitIndex};

let input = vec![0x00, 0x0A, 0xBC, 0xD0, 0xAB];

let mut re = BinRegex::new(".*A(BC)(F?)").unwrap();

let cap = re.captures(&input).unwrap();

let m0 = cap.get(0).unwrap();
assert_eq!(m0.start(), BitIndex::new(0, 0));
assert_eq!(m0.end(), BitIndex::new(3, 0));
assert_eq!(m0.span(), (BitIndex::new(0, 0), BitIndex::new(3, 0)));
assert_eq!(m0.is_empty(), false);

let m1 = cap.get(1).unwrap();
assert_eq!(m1.start(), BitIndex::new(2, 0));
assert_eq!(m1.end(), BitIndex::new(3, 0));
assert_eq!(m1.span(), (BitIndex::new(2, 0), BitIndex::new(3, 0)));
assert_eq!(m1.is_empty(), false);

let m2 = cap.get(2).unwrap();
assert_eq!(m2.start(), BitIndex::new(3, 0));
assert_eq!(m2.end(), BitIndex::new(3, 0));
assert_eq!(m2.span(), (BitIndex::new(3, 0), BitIndex::new(3, 0)));
assert_eq!(m2.is_empty(), true);

Implementations

impl<'a, T: BitIndexable> BinMatch<'a, T>

pub fn new(input: &'a T, start: BitIndex, end: BitIndex) -> BinMatch<'a, T>

Basic constructor for structure

pub fn start(&self) -> BitIndex

Accesses the start index of the match

pub fn end(&self) -> BitIndex

Accesses the end index of the match

pub fn is_empty(&self) -> bool

Returns true if the match is empty (start == end)

pub fn span(&self) -> (BitIndex, BitIndex)

Returns a tuple with the start and end indices of the match

pub fn as_bf(&self) -> BitField

Returns the contents of the match as a BitField

Trait Implementations

impl<'a, T: Clone + BitIndexable> Clone for BinMatch<'a, T>

fn clone(&self) -> BinMatch<'a, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, T: Debug + BitIndexable> Debug for BinMatch<'a, T>

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

Formats the value using the given formatter.

impl<'a, T: PartialEq + BitIndexable> PartialEq<BinMatch<'a, T>> for BinMatch<'a, T>

fn eq(&self, other: &BinMatch<'a, T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a, T: Copy + BitIndexable> Copy for BinMatch<'a, T>

impl<'a, T: Eq + BitIndexable> Eq for BinMatch<'a, T>

impl<'a, T: BitIndexable> StructuralEq for BinMatch<'a, T>

impl<'a, T: BitIndexable> StructuralPartialEq for BinMatch<'a, T>