99 lines
2.5 KiB
Rust
99 lines
2.5 KiB
Rust
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);
|
|
}
|
|
}
|