m8_file_parser/
version.rs

1use crate::{reader::*, writer::Writer};
2
3use std::fmt;
4
5#[derive(PartialEq, Clone, Copy)]
6pub struct Version {
7    pub major: u8,
8    pub minor: u8,
9    pub patch: u8,
10}
11
12impl Default for Version {
13    fn default() -> Self {
14        Self {
15            major: 4,
16            minor: 0,
17            patch: 0,
18        }
19    }
20}
21
22impl fmt::Display for Version {
23    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
24        write!(f, "{}.{}.{}", self.major, self.minor, self.patch)
25    }
26}
27
28impl fmt::Debug for Version {
29    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
30        write!(f, "{}", &self)
31    }
32}
33
34pub const FIRMWARE_3_0_SONG_VERSION : Version =
35    Version { major: 3, minor: 0, patch: 0 };
36
37/// eq introduction
38pub const FIRMWARE_4_0_SONG_VERSION : Version =
39    Version { major: 4, minor: 0, patch: 0 };
40
41/// 128 eq support
42pub const FIRMWARE_5_0_SONG_VERSION : Version =
43    Version { major: 4, minor: 1, patch: 0 };
44
45pub const FIRMWARE_6_0_SONG_VERSION : Version =
46    Version { major: 6, minor: 0, patch: 0 };
47
48pub const FIRMWARE_6_2_SONG_VERSION : Version =
49    Version { major: 6, minor: 1, patch: 0 };
50
51impl Version {
52    pub const SIZE: usize = 14;
53
54    pub fn new(major: u8, minor: u8) -> Version {
55        Version { major, minor, patch: 0 }
56    }
57
58    pub fn write(&self, w: &mut Writer) {
59        w.write_string("M8VERSION", 10);
60
61        w.write((self.minor << 4) | self.patch);
62        w.write(self.major);
63
64        w.write(0);
65        w.write(0x10); // why? don't know, but borked result if not written
66    }
67
68    pub fn from_reader(reader: &mut Reader) -> M8Result<Self> {
69        let _version_string = reader.read_bytes(10);
70        let lsb = reader.read();
71        let msb = reader.read();
72        let major = msb & 0x0F;
73        let minor = (lsb >> 4) & 0x0F;
74        let patch = lsb & 0x0F;
75
76        reader.read_bytes(2); // Skip
77        Ok(Self {
78            major,
79            minor,
80            patch,
81        })
82    }
83
84    pub fn after(&self, other: &Version) -> bool {
85        self.at_least(other.major, other.minor)
86    }
87
88    pub fn at_least(&self, major: u8, minor: u8) -> bool {
89        self.major > major || (self.major == major && self.minor >= minor)
90    }
91}