load from hex each type

db/src/lib.rs

@@ -1,3 +1,5 @@
+use binary_loader;
+
 struct DBHeader {
     magic: u8,
     major_version: u8, // actually u4 in data
@@ -7,22 +9,13 @@ struct DBHeader {
 }
 
 impl DBHeader {
-    fn from(raw: [u8; 8]) -> DBHeader {
+    fn from(raw: &[u8]) -> DBHeader {
-        
-        let mut reserved : u16 = 0x0000;
-        reserved = raw[2].into();
-        reserved <<= 8;
-        let temp : u16 = raw[3].into();
-        reserved |= temp;
-
-        let mut record_count : u32 = 0x00000000;
-
         DBHeader {
-            magic: raw[0],
+            magic: binary_loader::load_u8(&raw[0]),
-            major_version: (raw[1] | 0xF0) >> 4,
+            major_version: binary_loader::load_high_u4(&raw[1]),
-            minor_version: (raw[1] | 0x0F),
+            minor_version: binary_loader::load_low_u4(&raw[1]),
-            reserved: reserved,
+            reserved: binary_loader::load_u16(&raw[2..4]),
-            record_count: record_count,
+            record_count: binary_loader::load_u32(&raw[4..8]),
         }
     }
 }
@@ -33,13 +26,41 @@ struct RecordHeader {
     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,
-    value: String,
+    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);
@@ -48,7 +69,30 @@ mod tests {
     #[test]
     fn load_empty_db_header() {
         let header = [0xDB, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
-        let db_header = DBHeader::from(header);
+        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);
     }
 }