fit 0.5.0

A small crate used for reading and decoding FIT files generated by sports devices.
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 std::io::{Read, Seek, SeekFrom};

#[derive(Copy, Clone, PartialEq)]
pub enum Endianness {
    Little,
    Big,
}

pub fn read_u8<R>(map: &mut R) -> u8
where
    R: Read,
{
    let mut buf: [u8; 1] = [0];
    let _ = map.read(&mut buf);
    buf[0]
}
pub fn read_i8<R>(map: &mut R) -> i8
where
    R: Read,
{
    read_u8(map) as i8
}
pub fn read_u16<R>(map: &mut R, endianness: Endianness) -> u16
where
    R: Read,
{
    let arr = arr2(map);
    if endianness == Endianness::Little {
        u16::from_le_bytes(arr)
    } else {
        u16::from_be_bytes(arr)
    }
}
pub fn read_i16<R>(map: &mut R, endianness: Endianness) -> i16
where
    R: Read,
{
    let arr = arr2(map);
    if endianness == Endianness::Little {
        i16::from_le_bytes(arr)
    } else {
        i16::from_be_bytes(arr)
    }
}
pub fn read_u32<R>(map: &mut R, endianness: Endianness) -> u32
where
    R: Read,
{
    let arr = arr4(map);
    if endianness == Endianness::Little {
        u32::from_le_bytes(arr)
    } else {
        u32::from_be_bytes(arr)
    }
}
pub fn read_i32<R>(map: &mut R, endianness: Endianness) -> i32
where
    R: Read,
{
    let arr = arr4(map);
    if endianness == Endianness::Little {
        i32::from_le_bytes(arr)
    } else {
        i32::from_be_bytes(arr)
    }
}
pub fn read_u64<R>(map: &mut R, endianness: Endianness) -> u64
where
    R: Read,
{
    let arr = arr8(map);
    if endianness == Endianness::Little {
        u64::from_le_bytes(arr)
    } else {
        u64::from_be_bytes(arr)
    }
}
pub fn read_i64<R>(map: &mut R, endianness: Endianness) -> i64
where
    R: Read,
{
    let arr = arr8(map);
    if endianness == Endianness::Little {
        i64::from_le_bytes(arr)
    } else {
        i64::from_be_bytes(arr)
    }
}

fn arr2<R>(map: &mut R) -> [u8; 2]
where
    R: Read,
{
    let mut buf: [u8; 2] = [0; 2];
    let _ = map.read(&mut buf);
    buf
}

pub fn arr4<R>(map: &mut R) -> [u8; 4]
where
    R: Read,
{
    let mut buf: [u8; 4] = [0; 4];
    let _ = map.read(&mut buf);
    buf
}

fn arr8<R>(map: &mut R) -> [u8; 8]
where
    R: Read,
{
    let mut buf: [u8; 8] = [0; 8];
    let _ = map.read(&mut buf);
    buf
}

pub fn skip_bytes<R>(map: &mut R, s: u8)
where
    R: Seek,
{
    map.seek(SeekFrom::Current(s.into())).unwrap();
}