itelem 0.1.5

Parsing of iRacing .ibt telemetry file
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

use crate::{headers::VarHeader, read_bytes_file, ReadSeek};

#[derive(Debug, PartialEq)]
pub enum SampleValue {
    Char(char),
    Bool(bool),
    Int(i32),
    BitField(u32),
    Float32(f32),
    Float64(f64),
}

impl SampleValue {
    pub fn char(&self) -> char {
        if let SampleValue::Char(x) = self {
            *x
        } else {
            panic!()
        }
    }

    pub fn bool(&self) -> bool {
        if let SampleValue::Bool(x) = self {
            *x
        } else {
            panic!()
        }
    }

    pub fn float_32(&self) -> f32 {
        if let SampleValue::Float32(x) = self {
            *x
        } else {
            panic!()
        }
    }

    pub fn float_64(&self) -> f64 {
        if let SampleValue::Float64(x) = self {
            *x
        } else {
            panic!()
        }
    }

    pub fn int(&self) -> i32 {
        if let SampleValue::Int(x) = self {
            *x
        } else {
            panic!()
        }
    }

    pub fn bitfield(&self) -> u32 {
        if let SampleValue::BitField(x) = self {
            *x
        } else {
            panic!()
        }
    }
}

#[derive(Debug)]
pub struct Sample {
    data: Vec<u8>,
}

pub struct Samples<'a> {
    pub file: &'a mut dyn ReadSeek,
    pub length: i32,
    pub buf_offset: i32,
    pub current: i32,
}

impl Iterator for Samples<'_> {
    type Item = Sample;

    fn next(&mut self) -> Option<Self::Item> {
        let from = self.buf_offset + (self.current * self.length);
        match read_bytes_file(&mut self.file, from as usize, self.length as usize) {
            Ok(data) => {
                self.current += 1;
                Some(Sample { data })
            }
            Err(_) => None,
        }
    }
}

impl Sample {
    pub fn get_by_header(&self, var: &VarHeader) -> Option<SampleValue> {
        let offset = var.offset as usize;
        match var.r#type {
            0 => {
                let size = 1;
                Some(SampleValue::Char(self.data[offset + size] as char))
            }
            1 => {
                let size = 1;
                Some(SampleValue::Bool(self.data[offset + size] != 0))
            }
            2 => {
                let size = 4;
                let value =
                    i32::from_le_bytes(self.data[offset..(offset + size)].try_into().unwrap());
                Some(SampleValue::Int(value))
            }
            3 => {
                let size = 4;
                let value =
                    u32::from_le_bytes(self.data[offset..(offset + size)].try_into().unwrap());
                Some(SampleValue::BitField(value))
            }
            4 => {
                let size = 4;
                let value =
                    f32::from_le_bytes(self.data[offset..(offset + size)].try_into().unwrap());
                Some(SampleValue::Float32(value))
            }
            5 => {
                let size = 8;
                let value =
                    f64::from_le_bytes(self.data[offset..(offset + size)].try_into().unwrap());
                Some(SampleValue::Float64(value))
            }
            _ => unimplemented!(),
        }
    }
}