Struct Any

pub struct Any<I>(pub I);

Any matches uses all provided lookups and returns a match from a first successfull match.

It does checks lookups in order they were provided.

Example

use expectrl::{spawn, Any};

let mut p = spawn("cat").unwrap();
p.expect(Any(["we", "are", "here"])).unwrap();

To be able to combine different types of lookups you can call Any::boxed.

use expectrl::{spawn, Any, NBytes};

let mut p = spawn("cat").unwrap();
p.expect(Any::boxed(vec![Box::new("we"), Box::new(NBytes(3))])).unwrap();

Tuple Fields

0: I

Implementations

impl Any<Vec<Box<dyn Needle>>>

pub fn boxed(v: Vec<Box<dyn Needle>>) -> Self

Boxed expectes a list of Boxed lookups.

Examples found in repository

examples/expect_line.rs (lines 9-13)

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<I: Debug> Debug for Any<I>

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

Formats the value using the given formatter.

impl<T> Needle for Any<&[T]>

where T: Needle,

fn check(&self, buf: &[u8], eof: bool) -> Result<Vec<Match>, Error>

Function returns all matches that were occured.

impl<T, const N: usize> Needle for Any<&[T; N]>

where T: Needle,

fn check(&self, buf: &[u8], eof: bool) -> Result<Vec<Match>, Error>

Function returns all matches that were occured.

impl<T, const N: usize> Needle for Any<[T; N]>

where T: Needle,

fn check(&self, buf: &[u8], eof: bool) -> Result<Vec<Match>, Error>

Function returns all matches that were occured.

impl<T> Needle for Any<Vec<T>>

where T: Needle,

fn check(&self, buf: &[u8], eof: bool) -> Result<Vec<Match>, Error>

Function returns all matches that were occured.