Struct expectrl::Captures

pub struct Captures { /* private fields */ }

Captures is a represention of matched pattern.

It might represent an empty match.

Implementations

impl Captures

pub fn is_empty(&self) -> bool

is_empty verifies if any matches were actually found.

pub fn get(&self, index: usize) -> Option<&[u8]>

get returns a match by index.

Examples found in repository

examples/python.rs (line 14)

fn main() {
    let mut p = spawn_python().unwrap();

    p.execute("import platform").unwrap();
    p.send_line("platform.node()").unwrap();

    let found = p.expect(Regex(r"'.*'")).unwrap();

    println!(
        "Platform {}",
        String::from_utf8_lossy(found.get(0).unwrap())
    );
}

pub fn matches(&self) -> MatchIter<'_>

Matches returns a list of matches.

pub fn before(&self) -> &[u8]

before returns a bytes before match.

pub fn as_bytes(&self) -> &[u8]

as_bytes returns all bytes involved in a match, e.g. before the match and in a match itself.

In most cases the returned value equeals to concatanted Self::before and Self::matches. But sometimes like in case of crate::Regex it may have a grouping so Self::matches might overlap, therefore it will not longer be true.

Examples found in repository

examples/expect_line.rs (line 16)

fn main() {
    let mut session = expectrl::spawn("ls -al").expect("Can't spawn a session");

    loop {
        let m = session
            .expect(Any::boxed(vec![
                Box::new("\r"),
                Box::new("\n"),
                Box::new(Eof),
            ]))
            .expect("Expect failed");

        println!("{:?}", String::from_utf8_lossy(m.as_bytes()));

        let is_eof = m[0].is_empty();
        if is_eof {
            break;
        }

        if m[0] == [b'\n'] {
            continue;
        }

        println!("{:?}", String::from_utf8_lossy(&m[0]));
    }
}

Trait Implementations

impl Clone for Captures

fn clone(&self) -> Captures

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Captures

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

Formats the value using the given formatter.

impl Index<usize> for Captures

type Output = [u8]

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> IntoIterator for &'a Captures

type Item = &'a [u8]

The type of the elements being iterated over.

type IntoIter = MatchIter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq<Captures> for Captures

fn eq(&self, other: &Captures) -> 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 Eq for Captures

impl StructuralEq for Captures

impl StructuralPartialEq for Captures