Struct Rdp 

pub struct Rdp<T> { /* private fields */ }

Implementations

impl<'input, T: Input<'input>> Rdp<T>

pub fn new(input: T) -> Rdp<T>

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());
}

pub fn whitespace(&mut self) -> bool

pub fn any(&mut self) -> bool

pub fn soi(&mut self) -> bool

pub fn eoi(&mut self) -> bool

pub fn digit(&mut self) -> bool

pub fn integer(&mut self) -> bool

pub fn decimal(&mut self) -> bool

pub fn lowercase_letter(&mut self) -> bool

pub fn uppercase_letter(&mut self) -> bool

pub fn letter(&mut self) -> bool

pub fn symbol(&mut self) -> bool

pub fn repeat(&mut self) -> bool

pub fn sequence(&mut self) -> bool

pub fn decimal_list(&mut self) -> bool

pub fn voltage(&mut self) -> bool

pub fn current(&mut self) -> bool

pub fn temperature(&mut self) -> bool

pub fn humidity(&mut self) -> bool

pub fn pressure(&mut self) -> bool

pub fn custom(&mut self) -> bool

pub fn sun(&mut self) -> bool

pub fn rssi(&mut self) -> bool

pub fn count(&mut self) -> bool

pub fn windspeed(&mut self) -> bool

pub fn location(&mut self) -> bool

pub fn zombie_mode(&mut self) -> bool

pub fn zombie(&mut self) -> bool

pub fn data_field(&mut self) -> bool

pub fn data(&mut self) -> bool

pub fn comment_content(&mut self) -> bool

pub fn comment(&mut self) -> bool

pub fn node_name_content(&mut self) -> bool

pub fn node_name(&mut self) -> bool

pub fn path(&mut self) -> bool

pub fn packet(&mut self) -> bool

Examples found in repository

examples/cli.rs (line 15)

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());
}

pub fn try<F>(&mut self, revert: bool, rule: F) -> bool

where F: FnOnce(&mut Self) -> bool,

pub fn prec_climb<F, G>( &mut self, pos: usize, left: usize, min_prec: u8, last_op: Option<(Option<Rule>, u8, bool)>, primary: &mut F, climb: &mut G, ) -> (Option<(Option<Rule>, u8, bool)>, Option<usize>)

where F: FnMut(&mut Self) -> bool, G: FnMut(&mut Self) -> Option<(Option<Rule>, u8, bool)>,

pub fn _repeat(&self) -> u8

pub fn _sequence(&self) -> char

pub fn _location(&self) -> Location

pub fn _windspeed(&self) -> WindSpeed

pub fn _decimal_list(&self) -> Vec<f32>

pub fn _zombie(&self) -> u8

pub fn _datafield(&self) -> DataField

pub fn _data(&self) -> Vec<DataField>

pub fn _comment(&self) -> Option<String>

pub fn _node_name(&self) -> String

pub fn _path(&self) -> Vec<String>

pub fn parse(&self) -> Packet

Examples found in repository

examples/cli.rs (line 57)

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<'input, T: Input<'input>> Parser<'input, T> for Rdp<T>

type Rule = Rule

type Token = Token<Rule>

fn input(&self) -> &T

fn input_mut(&mut self) -> &mut T

fn end(&self) -> bool

Returns whether a Parser has reached its end.

fn eoi_matched(&self) -> bool

Returns whether a Parser has matched end-of-input.

fn reset(&mut self)

Reset a Parser.

fn queue(&self) -> &Vec<Token<Rule>>

Returns the queue of all matched Tokens.

fn queue_mut(&mut self) -> &mut Vec<Token<Rule>>

Returns the mutable queue of all matched Tokens.

fn queue_with_captures(&self) -> Vec<(Token<Rule>, String)>

Returns the queue of all matched (Token, value)s.

fn queue_index(&self) -> usize

Returns the current index within the queue. Used in process!.

fn inc_queue_index(&self)

Increments the current index within the queue. Used in process!.

fn set_queue_index(&self, index: usize)

Set the current index within the queue. Used in process!.

fn skip(&mut self)

Skips whitespace and comments.

fn is_atomic(&self) -> bool

Returns whether a Parser is currently inside an atomic rule.

fn set_atomic(&mut self, value: bool)

Sets a Parser to atomic rule mode, barring comment & white-space skipping.

fn track(&mut self, failed: Rule, pos: usize)

Keeps track of rule failures. It gets called when a Rule fails at pos.

fn tracked_len_pos(&self) -> (usize, usize)

Returns the length of the tracked Rules.

fn expected(&mut self) -> (Vec<Rule>, usize)

Retuns a Vec of all expected Rules at the deepest position where the parsing last stopped. It only returns leafs from the rule tree. Used for error reporting.

fn stack(&self) -> &Vec<String>

Returns the stack Vec.

fn stack_mut(&mut self) -> &mut Vec<String>

Returns the mutable stack Vec.