fitparser 0.4.0

A utility to parse ANT .FIT files and allow their contents to be serialized with serde.
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
147
148
149
150
151
152
153
154
155

//! Defines the FIT profile used to convert raw parser output into final values that can be
//! interpreted without using the FIT profile.
use std::collections::HashMap;

pub mod field_types;
pub use field_types::{get_field_variant_as_string, FieldDataType, MesgNum};

pub mod messages;
pub use messages::VERSION;

/// Describes a single message pulled from the FIT profile.
#[derive(Clone, Debug)]
pub struct MessageInfo {
    name: &'static str,
    global_message_number: MesgNum,
    fields: HashMap<u8, FieldInfo>,
}

impl MessageInfo {
    /// Return message name as defined in FIT profile
    pub fn name(&self) -> &'static str {
        self.name
    }

    /// Return global message number as defined in FIT profile
    pub fn global_message_number(&self) -> MesgNum {
        self.global_message_number
    }

    /// Return reference to defined set of fields
    pub fn fields(&self) -> &HashMap<u8, FieldInfo> {
        &self.fields
    }
}

/// Describes a single field within a message pulled from the FIT profile
#[derive(Clone, Debug)]
pub struct FieldInfo {
    name: &'static str,
    field_type: FieldDataType,
    def_number: u8,
    scale: f64,
    offset: f64,
    units: &'static str,
    accumulate: bool,
    subfields: Vec<(u8, i64, FieldInfo)>,
    components: Vec<ComponentFieldInfo>,
}

impl FieldInfo {
    /// Get units of field
    pub fn name(&self) -> &'static str {
        self.name
    }

    /// Get field type
    pub fn field_type(&self) -> FieldDataType {
        self.field_type
    }

    /// Get definition number as defined in the FIT profile
    pub fn def_number(&self) -> u8 {
        self.def_number
    }

    /// Get scale used to convert field value into a float
    pub fn scale(&self) -> f64 {
        self.scale
    }

    /// Get offset to shift field value by
    pub fn offset(&self) -> f64 {
        self.offset
    }

    /// Get units of field
    pub fn units(&self) -> &'static str {
        self.units
    }

    /// Check whether or not this field is accumlated across multiple messages
    pub fn accumulate(&self) -> bool {
        self.accumulate
    }

    /// Get components of field if any
    pub fn components(&self) -> &[ComponentFieldInfo] {
        &self.components
    }

    /// Get subfields of field if any, these are stored as a tuple of values
    /// (referenced field defition num, expected referenced field value, subfield field info)
    pub fn subfields(&self) -> &[(u8, i64, FieldInfo)] {
        &self.subfields
    }
}

/// Describes a componet field within a larger field pulled from the FIT profile
#[derive(Clone, Debug)]
pub struct ComponentFieldInfo {
    dest_def_number: u8,
    scale: f64,
    offset: f64,
    units: &'static str,
    bits: u8,
    accumulate: bool,
}

impl ComponentFieldInfo {
    /// Expand the component info into a full FieldInfo struct
    pub fn to_field_info(&self, info: &FieldInfo) -> FieldInfo {
        FieldInfo {
            name: info.name(),
            field_type: info.field_type(),
            def_number: info.def_number(),
            scale: self.scale(),
            offset: self.offset(),
            units: self.units(),
            accumulate: self.accumulate(),
            subfields: info.subfields().to_vec(),
            // double component expansion breaks scale/offset adjustment
            components: Vec::new(), // info.components.clone(),
        }
    }

    /// Destination definition number to use once the component is expanded
    pub fn dest_def_number(&self) -> u8 {
        self.dest_def_number
    }

    /// Get scale used to convert field value into a float
    pub fn scale(&self) -> f64 {
        self.scale
    }

    /// Get offset to shift field value by
    pub fn offset(&self) -> f64 {
        self.offset
    }

    /// Get units of field
    pub fn units(&self) -> &'static str {
        self.units
    }

    /// Get bitmask needed for this field during expansion
    pub fn bits(&self) -> u8 {
        self.bits
    }

    /// Check whether or not this field is accumlated across multiple messages
    pub fn accumulate(&self) -> bool {
        self.accumulate
    }
}