simetry 0.2.3

Interface with telemetry of various racing and driving sims
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

use crate::iracing::header::{VarHeader, VarType};
use byteorder::{LittleEndian, ReadBytesExt};

pub trait VarData: Sized {
    fn parse_from_raw(entry: usize, header: &VarHeader, data: &[u8]) -> Option<Self> {
        if entry >= header.count {
            return None;
        }
        let leftover = header.count - entry;
        let entry_size = header.var_type.byte_count();
        let start = header.offset + entry * entry_size;
        let end = start + leftover * entry_size;
        Self::parse(header.var_type, &data[start..end])
    }

    /// Read value from location in data.
    ///
    /// Count is guaranteed to be at least 1.
    fn parse(var_type: VarType, data: &[u8]) -> Option<Self>;
}

#[derive(Clone, Debug, PartialEq)]
pub enum Value {
    Char(u8),
    Bool(bool),
    Int(i32),
    BitField(u32),
    Float(f32),
    Double(f64),
}

impl std::fmt::Display for Value {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Value::Char(v) => write!(f, "{}", v),
            Value::Bool(v) => write!(f, "{}", v),
            Value::Int(v) => write!(f, "{}", v),
            Value::BitField(v) => write!(f, "{:#032b}", v),
            Value::Float(v) => write!(f, "{}", v),
            Value::Double(v) => write!(f, "{}", v),
        }
    }
}

impl VarData for Value {
    fn parse(var_type: VarType, data: &[u8]) -> Option<Self> {
        match var_type {
            VarType::Char => VarData::parse(var_type, data).map(Value::Char),
            VarType::Bool => VarData::parse(var_type, data).map(Value::Bool),
            VarType::Int => VarData::parse(var_type, data).map(Value::Int),
            VarType::BitField => VarData::parse(var_type, data).map(Value::BitField),
            VarType::Float => VarData::parse(var_type, data).map(Value::Float),
            VarType::Double => VarData::parse(var_type, data).map(Value::Double),
        }
    }
}

impl<T: VarData> VarData for Vec<T> {
    fn parse(var_type: VarType, data: &[u8]) -> Option<Self> {
        Some(
            data.chunks(var_type.byte_count())
                .filter_map(|chunk| T::parse(var_type, chunk))
                .collect(),
        )
    }
}

impl VarData for u8 {
    fn parse(var_type: VarType, mut data: &[u8]) -> Option<Self> {
        match var_type {
            VarType::Char | VarType::Bool => data.read_u8().ok(),
            _ => None,
        }
    }
}

impl VarData for bool {
    fn parse(var_type: VarType, mut data: &[u8]) -> Option<Self> {
        match var_type {
            VarType::Char | VarType::Bool => data.read_u8().ok().map(|v| v != 0),
            _ => None,
        }
    }
}

impl VarData for i32 {
    fn parse(var_type: VarType, mut data: &[u8]) -> Option<Self> {
        match var_type {
            VarType::Char => data.read_u8().ok().map(|v| v as i32),
            VarType::Int => data.read_i32::<LittleEndian>().ok(),
            _ => None,
        }
    }
}

impl VarData for u32 {
    fn parse(var_type: VarType, mut data: &[u8]) -> Option<Self> {
        match var_type {
            VarType::BitField => data.read_u32::<LittleEndian>().ok(),
            _ => None,
        }
    }
}

impl VarData for f32 {
    fn parse(var_type: VarType, mut data: &[u8]) -> Option<Self> {
        match var_type {
            VarType::Float => data.read_f32::<LittleEndian>().ok(),
            _ => None,
        }
    }
}

impl VarData for f64 {
    fn parse(var_type: VarType, mut data: &[u8]) -> Option<Self> {
        match var_type {
            VarType::Float => data.read_f32::<LittleEndian>().ok().map(|v| v as f64),
            VarType::Double => data.read_f64::<LittleEndian>().ok(),
            _ => None,
        }
    }
}