load from hex each type

Cargo.toml

@@ -7,3 +7,4 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+db = { path = "db" }

binary_loader/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "binary_loader"
+version = "0.1.0"
+authors = ["Jon Janzen <jon@endofeternity.ca>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

binary_loader/src/lib.rs

@@ -0,0 +1,94 @@
+pub fn load_high_u4(raw: &u8) -> u8 {
+    (raw & 0xF0) >> 4
+}
+
+pub fn load_low_u4(raw: &u8) -> u8 {
+    raw & 0x0F
+}
+
+pub fn load_u8(raw: &u8) -> u8 {
+    raw & 0xFF
+}
+
+pub fn load_u16(raw: &[u8]) -> u16 {
+    let temp: u16 = raw[0].into();
+    let mut value: u16 = temp << 8;
+    let temp: u16 = raw[1].into();
+    value |= temp;
+    value
+}
+
+pub fn load_u32(raw: &[u8]) -> u32 {
+    let temp: u32 = raw[0].into();
+    let mut value: u32 = temp << 24;
+    let temp: u32 = raw[1].into();
+    value |= temp << 16;
+    let temp: u32 = raw[2].into();
+    value |= temp << 8;
+    let temp: u32 = raw[3].into();
+    value |= temp;
+    value
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn load_0() {
+        assert_eq!(0, load_u32(&[0, 0, 0, 0]));
+    }
+    
+    #[test]
+    fn load_1() {
+        assert_eq!(1, load_u32(&[0, 0, 0, 1]));
+    }
+    
+    #[test]
+    fn load_big() {
+        let my_arr = [1, 0, 0, 2, 1, 1];
+        let slice = &my_arr[0..4];
+        assert_eq!(0x01000002, load_u32(&slice));
+    }
+
+    #[test]
+    fn test_load_low_u4() {
+        assert_eq!(0x07, load_low_u4(&0x07));
+    }
+    
+    #[test]
+    fn load_low_u4_with_high_data() {
+        assert_eq!(0x03, load_low_u4(&0x13));
+    }
+
+    #[test]
+    fn load_low_u4_with_only_high_data() {
+        assert_eq!(0x00, load_low_u4(&0x30));
+    }
+
+    #[test]
+    fn test_load_high_u4() {
+        assert_eq!(0x07, load_high_u4(&0x70));
+    }
+    
+    #[test]
+    fn load_high_u4_with_low_data() {
+        assert_eq!(0x01, load_high_u4(&0x13));
+    }
+
+    #[test]
+    fn load_high_u4_with_only_low_data() {
+        assert_eq!(0x00, load_high_u4(&0x03));
+    }
+
+    #[test]
+    fn test_load_u8() {
+        assert_eq!(0x43, load_u8(&0x43));
+    }
+
+    #[test]
+    fn test_load_u16() {
+        let my_arr = [0x34, 0x23];
+        assert_eq!(0x3423, load_u16(&my_arr));
+    }
+}

db/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "db"
+version = "0.1.0"
+authors = ["Jon Janzen <jon@endofeternity.ca>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+binary_loader = { path = "../binary_loader" }

db/src/lib.rs

@@ -0,0 +1,98 @@
+use binary_loader;
+
+struct DBHeader {
+    magic: u8,
+    major_version: u8, // actually u4 in data
+    minor_version: u8, // actually u4 in data 
+    reserved: u16,
+    record_count: u32,
+}
+
+impl DBHeader {
+    fn from(raw: &[u8]) -> DBHeader {
+        DBHeader {
+            magic: binary_loader::load_u8(&raw[0]),
+            major_version: binary_loader::load_high_u4(&raw[1]),
+            minor_version: binary_loader::load_low_u4(&raw[1]),
+            reserved: binary_loader::load_u16(&raw[2..4]),
+            record_count: binary_loader::load_u32(&raw[4..8]),
+        }
+    }
+}
+
+struct RecordHeader {
+    field_count: u8,
+    length: u8,
+    crc: u16,
+}
+
+impl RecordHeader {
+    fn from(raw: &[u8]) -> RecordHeader {
+        RecordHeader {
+            field_count: binary_loader::load_u8(&raw[0]),
+            length: binary_loader::load_u8(&raw[1]),
+            crc: binary_loader::load_u16(&raw[2..4]),
+        }
+    }
+}
+
+struct Field {
+    field_type: u8,
+    length: u16,
+    value: String, 
+}
+
+impl Field {
+    fn from(raw: &[u8]) -> Field {
+        let length = binary_loader::load_u16(&raw[1..3]);
+        let mut lsize: usize = length.into();
+        lsize += 3;
+        let value = String::from_utf8_lossy(&raw[3..lsize]).to_string();
+        println!("{}", value);
+        println!("{}", lsize);
+        Field {
+            field_type: binary_loader::load_u8(&raw[0]),
+            length: length,
+            value: value,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn it_works() {
+        assert_eq!(2 + 2, 4);
+    }
+    
+    #[test]
+    fn load_empty_db_header() {
+        let header = [0xDB, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
+        let db_header = DBHeader::from(&header);
+        assert_eq!(db_header.magic, 0xDB);
+        assert_eq!(db_header.major_version, 0);
+        assert_eq!(db_header.minor_version, 1);
+        assert_eq!(db_header.reserved, 0);
+        assert_eq!(db_header.record_count, 0);
+
+    }
+    
+    #[test]
+    fn load_record_header() {
+        let header: [u8; 4] = [0x3, 0x45, 0x12, 0x34];
+        let record_header = RecordHeader::from(&header);
+        assert_eq!(record_header.field_count, 3);
+        assert_eq!(record_header.length, 0x45);
+        assert_eq!(record_header.crc, 0x1234);
+    }
+
+    #[test]
+    fn load_field() {
+        let field: [u8; 6] = [0x01, 0x00, 0x03, 0x4a, 0x6f, 0x6e];
+        let field = Field::from(&field);
+        assert_eq!(0x01, field.field_type);
+        assert_eq!(3, field.length);
+        assert_eq!(String::from("Jon"), field.value);
+    }
+}