Struct StringInput

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

A struct useful for matching in-memory Strings.

Examples

let mut input = StringInput::new("asdasdf");

assert!(input.match_string("asd"));
assert!(input.match_string("asdf"));
assert!(!input.match_string("nope"));

Implementations

impl<'a> StringInput<'a>

pub fn new(string: &'a str) -> StringInput<'a>

Creates a new StringInput from a &str.

Examples

let mut input = StringInput::new("asd");

assert_eq!(input.len(), 3);

Examples found in repository

examples/cli.rs (line 13)

fn main() {
    let packet = if args().len() == 2 {
        args().nth(1).unwrap()
    } else {
        "2bT12.34,15H38W123Z1:hello world[AG]".to_owned()
    };
    println!("Parsing '{}':", packet);

    let mut parser = Rdp::new(StringInput::new(&packet));

    match parser.packet() {
        true => println!("Parsed OK:"),
        false => {
            let (expected, position) = parser.expected();

            println!("Failure at input position {}", position);
            println!("\n{}", packet);
            for _ in 0..position { print!(" "); }
            println!("^");

            println!("Expected one of:");
            println!("{:?}", expected);

            let err = ParserError::from_parser(&mut parser);
            println!("Error: {:?}", err);

            panic!("Cannot proceed");
        }
    };

    let mut indent = 0;
    let mut parents = vec![&parser.queue()[0]];
    let mut prev_t = parents[0];

    for t in parser.queue() {
        if t.start >= prev_t.start && t.end <= prev_t.end {
            indent += 1;
            parents.push(prev_t);
        } else {
            while t.start >= parents.last().unwrap().end {
                parents.pop();
                indent -= 1;
            }
        }
        for _ in 0..(indent-1) {
            print!("    ");
        }
        println!("{:?} {}-{}", t.rule, t.start, t.end);
        prev_t = t;
    }
    println!("");

    println!("{:?}", parser.parse());
}

Trait Implementations

impl<'a> Input<'a> for StringInput<'a>

fn len(&self) -> usize

Returns length of an Input.

fn is_empty(&self) -> bool

Returns whether an Input is empty.

fn pos(&self) -> usize

Returns current position of an Input.

fn set_pos(&mut self, pos: usize)

Set current position of an Input.

fn slice(&self, start: usize, end: usize) -> &'a str

Slices an Input.

fn line_col(&self, pos: usize) -> (usize, usize)

Returns the line and column of a position for an Input.

fn match_string(&mut self, string: &str) -> bool

Matches string to an Input, returns whether it matched, and advances the position with string.len() in case it did.

fn match_insensitive(&mut self, string: &str) -> bool

Matches string to an Input case insensitively, returns whether it matched, and advances the position with string.len() in case it did.

fn match_range(&mut self, left: char, right: char) -> bool

Matches if an Input’s current char is between left and right, and advances the position with one char in case it did.