nom-derive 0.6.0-beta2

Custom derive nom parsers from struct
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

#[allow(unused_imports)]
#[macro_use]
extern crate pretty_assertions;

use nom_derive::Nom;

/// A structure with a length and a Vec
#[derive(Debug,PartialEq,Nom)]
struct S1 {
    pub a: u32,
    #[nom(Count="a")]
    pub b: Vec<u32>,
    pub c: u32,
}

#[derive(Debug,PartialEq,Nom)]
struct NewType(pub u8);

/// A structure with a length and a Vec of structs
#[derive(Debug,PartialEq,Nom)]
struct S2 {
    pub a: u8,
    #[nom(Count="a")]
    pub b: Vec<NewType>,
}

/// A structure Vec of structs, count with literal
#[derive(Debug,PartialEq,Nom)]
struct S3 {
    #[nom(Count="2")]
    pub b: Vec<NewType>,
}

#[derive(Debug, PartialEq, Nom)]
struct S4 {
    pub a: u8,
    #[nom(Value="a+1")]
    pub b: u8,
    #[nom(Value="b.to_string()")]
    pub s: String,
}


#[test]
fn test_struct_count() {
    let input = b"\x00\x00\x00\x02\x12\x34\x56\x78\x12\x34\x56\x78\x00\x00\x00\x01";
    let res = S1::parse(input);
    assert_eq!(res, Ok((&input[16..],S1{a:2, b:vec![0x12345678,0x12345678], c:1})));
}

#[test]
fn test_struct_count_newtype() {
    let input = b"\x02\x12\x34";
    let res = S2::parse(input);
    assert_eq!(res, Ok((&input[3..],S2{a:2, b:vec![NewType(0x12),NewType(0x34)]})));
}

#[test]
fn test_struct_count_literal() {
    let input = b"\x12\x34";
    let res = S3::parse(input);
    assert_eq!(res, Ok((&input[2..],S3{b:vec![NewType(0x12),NewType(0x34)]})));
}

#[test]
fn test_struct_value() {
    let input = b"\x12\x34";
    let res = S4::parse(input);
    assert_eq!(res, Ok((&input[1..],
        S4{a:0x12, b:0x13, s:"19".to_string()}
        )));
}