load from hex each type

db/src/lib.rs

@@ -9,8 +9,7 @@ struct DBHeader {
 }
 
 impl DBHeader {
-    fn from(raw: [u8; 8]) -> DBHeader {
-        
+    fn from(raw: &[u8]) -> DBHeader {
         DBHeader {
             magic: binary_loader::load_u8(&raw[0]),
             major_version: binary_loader::load_high_u4(&raw[1]),
@@ -27,9 +26,36 @@ 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)]
@@ -43,7 +69,7 @@ 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);
@@ -51,4 +77,22 @@ mod tests {
         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);
+    }
 }