lin-ldf 0.0.28

Parser for LDF files that describe automotive LIN bus networks.
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use crate::ldf::ldf_comment::skip_whitespace;
use nom::{
    bytes::complete::{tag, take_while},
    IResult,
};

/// `Schedule_tables` section of a LIN Description File (LDF)
/// ```text
/// Schedule_tables {
///   AllFrames {
///      Frame1 delay 10 ms ;
///      Frame2 delay 10 ms ;
///   }
/// }
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct LdfScheduleTable {
    /// Schedule table name.
    /// All schedule_table_name identifiers shall be unique within the schedule table identifier set
    pub schedule_table_name: String,

    /// Frame delays
    pub frame_delays: Vec<LdfFrameDelay>,
}

/// Frame delay in a schedule table in a LIN Description File (LDF).
/// ```text
/// Frame1 delay 10 ms ;
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct LdfFrameDelay {
    /// Frame name
    pub frame_name: String,

    /// Frame delay in milliseconds
    pub frame_time: f32,
}

/*
Schedule_tables {
  AllFrames {
     Frame1 delay 10 ms ;
     Frame2   delay 10.0 ms ;
  }
}
*/

pub fn parse_ldf_schedule_tables(s: &str) -> IResult<&str, Vec<LdfScheduleTable>> {
    // `Schedule_tables {` or `Schedule_tables{` or ...
    // - May be any number of spaces before and after the "Schedule_tables" tag
    // - May be any number of spaces before and after the opening curly brace
    let (s, _) = skip_whitespace(s)?;
    let (s, _) = tag("Schedule_tables")(s)?;
    let (s, _) = skip_whitespace(s)?;
    let (s, _) = tag("{")(s)?;

    let mut schedule_tables = Vec::new();
    let mut remaining = s;

    while !remaining.starts_with('}') {
        // `AllFrames: {` or `AllFrames:{` or ...
        // - May be any number of spaces before and after the "AllFrames" tag
        // - May be any number of spaces before and after the opening curly brace
        let (s, _) = skip_whitespace(remaining)?;
        let (s, schedule_table_name) = take_while(|c: char| c.is_alphanumeric() || c == '_')(s)?;
        let (s, _) = skip_whitespace(s)?;
        let (s, _) = tag("{")(s)?;

        let mut frame_delays = Vec::new();
        remaining = s;

        while !remaining.starts_with('}') {
            // `Frame1 delay 10 ms ;` or `Frame1 delay 10 ms;` or ...
            // - May be any number of spaces before and after the frame name
            // - May be any number of spaces before and after the "delay" tag
            // - May be any number of spaces before and after the frame delay
            // - May be any number of spaces before and after the "ms" tag
            // - May be any number of spaces before and after the semicolon
            let (s, _) = skip_whitespace(remaining)?;
            let (s, frame_name) = take_while(|c: char| c.is_alphanumeric() || c == '_')(s)?;
            let (s, _) = skip_whitespace(s)?;
            let (s, _) = tag("delay")(s)?;
            let (s, _) = skip_whitespace(s)?;
            let (s, frame_time) = take_while(|c: char| c.is_numeric() || c == '.')(s)?;
            let (s, _) = skip_whitespace(s)?;
            let (s, _) = tag("ms")(s)?;
            let (s, _) = skip_whitespace(s)?;
            let (s, _) = tag(";")(s)?;
            let (s, _) = skip_whitespace(s)?;

            frame_delays.push(LdfFrameDelay {
                frame_name: frame_name.to_string(),
                frame_time: frame_time.parse().unwrap(),
            });

            remaining = s;
        }

        let (s, _) = tag("}")(remaining)?;
        let (s, _) = skip_whitespace(s)?;

        schedule_tables.push(LdfScheduleTable {
            schedule_table_name: schedule_table_name.to_string(),
            frame_delays,
        });

        remaining = s;
    }

    let (remaining, _) = tag("}")(remaining)?;

    Ok((remaining, schedule_tables))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_ldf_schedule_tables() {
        let input = r#"
            Schedule_tables {
                AllFrames {
                    Frame1 delay 10 ms ;
                    Frame2   delay 10.0 ms ;
                }
            }
        "#;

        let (_, schedule_tables) = parse_ldf_schedule_tables(input).unwrap();

        assert_eq!(schedule_tables.len(), 1);

        let schedule_table = &schedule_tables[0];
        assert_eq!(schedule_table.schedule_table_name, "AllFrames");
        assert_eq!(schedule_table.frame_delays.len(), 2);

        let frame_delay = &schedule_table.frame_delays[0];
        assert_eq!(frame_delay.frame_name, "Frame1");
        assert_eq!(frame_delay.frame_time, 10.0);

        let frame_delay = &schedule_table.frame_delays[1];
        assert_eq!(frame_delay.frame_name, "Frame2");
        assert_eq!(frame_delay.frame_time, 10.0);
    }
}