derailleur 0.1.0

An efficient deserializer for Garmin's Flexible and Interoperable Data Transfer protocol.
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

//! States processing document and record headers.

use either::Either::{self, Left, Right};
use tartan_bitfield::bitfield;
use thiserror::Error;
use zerocopy::FromBytes;

use super::definition::{Definition, DefinitionAlt};

/// An error advancing over a document header.
#[derive(Debug, Error)]
pub enum DocumentHeaderError {
    /// Incorrect filetype marker.
    #[error("Incorrect file type marker.")]
    NotFitData,
    /// Unknown header length.
    #[error("Unknown header length ({0}).")]
    UnknownHeaderLength(u8),
}

/// State token to decode a document header.
#[derive(Debug)]
pub struct DocumentHeader;

impl DocumentHeader {
    /// Transition to another state by decoding a document header.
    ///
    /// Returns the number of record bytes in this document, and a successor
    /// state token.
    pub fn advance(
        r: [u8; 12],
    ) -> Result<(u32, Either<ExtendedDocumentHeader, RecordHeader>), DocumentHeaderError> {
        #[repr(C, packed)]
        #[derive(FromBytes)]
        struct FileHeader {
            header_size: u8,
            protocol_version: u8,
            profile_version: u16,
            data_size: u32,
            data_type: [u8; 4],
        }

        let FileHeader {
            header_size,
            data_size,
            data_type,
            ..
        } = zerocopy::transmute!(r);

        if &data_type != b".FIT" {
            Err(DocumentHeaderError::NotFitData)?;
        }

        let successor = match header_size {
            14 => Left(ExtendedDocumentHeader(())),
            12 => Right(RecordHeader(())),
            _ => Err(DocumentHeaderError::UnknownHeaderLength(header_size))?,
        };

        Ok((data_size, successor))
    }
}

/// State token to decode additional bytes of an extended document header.
#[derive(Debug)]
pub struct ExtendedDocumentHeader(pub(super) ());

impl ExtendedDocumentHeader {
    /// Transition to another state by decoding the additional bytes of an
    /// extended document header.
    ///
    /// Returns the successor state token.
    pub fn advance(self, _r: [u8; 2]) -> RecordHeader {
        RecordHeader(())
    }
}

/// An error advancing over a record header.
#[derive(Debug, Error)]
pub enum RecordHeaderError {
    /// Found developer data (not yet supported).
    #[error("Found developer data.")]
    DeveloperData,
}

/// State token to decode a record header.
#[derive(Debug)]
pub struct RecordHeader(pub(super) ());

impl RecordHeader {
    /// Transition to another state by decoding a record header.
    ///
    /// Returns the local message number, a successor state token, and for
    /// record headers, the time offset if present.
    pub fn advance(
        self,
        r: [u8; 1],
    ) -> Result<(u8, Either<Definition, (Option<u8>, DefinitionAlt)>), RecordHeaderError> {
        let r = r[0];

        bitfield! {
            struct RecordHeader(u8) {
                [7] is_compressed,
            }
        }

        let header = RecordHeader(r);

        if header.is_compressed() {
            bitfield! {
                struct CompressedHeader(u8) {
                    [0..5] time_offset: u8,
                    [5..7] local_message: u8,
                }
            }

            let header = CompressedHeader(r);

            let local_message = header.local_message();
            let time_offset = header.time_offset();

            let successor = Right((Some(time_offset), DefinitionAlt(())));

            Ok((local_message, successor))
        } else {
            bitfield! {
                struct NormalHeader(u8) {
                    [0..4] local_message: u8,
                    [5] is_developer,
                    [6] is_definition,
                }
            }

            let header = NormalHeader(r);

            let local_message = header.local_message();
            if header.is_developer() {
                Err(RecordHeaderError::DeveloperData)?;
            }

            let successor = if header.is_definition() {
                Left(Definition(()))
            } else {
                Right((None, DefinitionAlt(())))
            };

            Ok((local_message, successor))
        }
    }
}