422 lines
12 KiB
Rust
422 lines
12 KiB
Rust
///
|
|
/// Generic record-level read/write functionality.
|
|
///
|
|
use std::io::Write;
|
|
use std::convert::TryInto;
|
|
use byteorder::{ByteOrder, BigEndian};
|
|
|
|
|
|
use crate::basic::{pack_datetime, pack_bitarray, pack_ascii, pack_int2, pack_int4, pack_real8}; #[warn(unused_imports)]
|
|
use crate::basic::{parse_datetime, parse_bitarray, parse_ascii, parse_int2, parse_int4, parse_real8}; #[warn(unused_imports)]
|
|
use crate::basic::{OResult, IResult, fail, parse_u16, take_bytes}; //ErrType,
|
|
use crate::records;
|
|
|
|
|
|
//#[no_mangle]
|
|
//pub extern "C" fn write_record_header(
|
|
|
|
|
|
#[repr(C)]
|
|
pub struct RecordHeader {
|
|
pub tag: u16,
|
|
pub data_size: u16,
|
|
}
|
|
|
|
impl RecordHeader {
|
|
pub fn read(input: &[u8]) -> IResult<RecordHeader> {
|
|
let (input, size) = parse_u16(input)?;
|
|
let (input, tag) = parse_u16(input)?;
|
|
Ok((input, RecordHeader{tag, data_size:size - 4}))
|
|
}
|
|
|
|
pub fn pack_into(&self) -> [u8; 4] {
|
|
assert!(self.data_size < 0xffff - 4, "Record too big!");
|
|
let vals = [self.data_size, self.tag];
|
|
let mut buf = [0x77; 4];
|
|
BigEndian::write_u16_into(&vals, &mut buf);
|
|
buf
|
|
}
|
|
|
|
pub fn write<W: Write>(&self, ww: &mut W) -> OResult {
|
|
let bytes = self.pack_into();
|
|
ww.write(&bytes)
|
|
}
|
|
}
|
|
|
|
|
|
pub trait RecordData {
|
|
type BareData<'a>;
|
|
type InData : ?Sized;
|
|
type ByteData : AsRef<[u8]>;
|
|
|
|
fn read(input: &[u8], size: u16) -> IResult<Self::BareData<'_>>;
|
|
fn pack_into(buf: &mut [u8], data: &Self::InData);
|
|
//fn size(data: &Self::BareData<'_>) -> u16;
|
|
fn pack(data: &Self::InData) -> Self::ByteData;
|
|
}
|
|
|
|
|
|
pub trait Record<RData: RecordData> {
|
|
fn tag() -> u16;
|
|
fn expected_size() -> Option<u16>;
|
|
|
|
fn check_size(actual_size: u16) -> Result<(), String> {
|
|
match Self::expected_size() {
|
|
Some(size) => if size == actual_size {
|
|
Ok(())
|
|
} else {
|
|
Err(format!("Expected record size {}, got {}", size, actual_size))
|
|
},
|
|
None => Ok(()),
|
|
}
|
|
}
|
|
|
|
fn read_header(input: &[u8]) -> IResult<RecordHeader> {
|
|
RecordHeader::read(input)
|
|
}
|
|
|
|
fn write_header<W: Write>(ww: &mut W, data_size: u16) -> OResult {
|
|
RecordHeader{tag: Self::tag(), data_size}.write(ww)
|
|
}
|
|
|
|
fn read_data(input: &[u8], size: u16) -> IResult<RData::BareData<'_>> {
|
|
RData::read(input, size)
|
|
}
|
|
|
|
fn pack_data(buf: &mut [u8], data: &RData::InData) {
|
|
RData::pack_into(buf, data)
|
|
}
|
|
|
|
///
|
|
/// Skip to the end of the next occurence of this record.
|
|
///
|
|
/// Return:
|
|
/// True if the record was encountered and skipped.
|
|
/// False if the end of the library was reached.
|
|
///
|
|
fn skip_past(input: &[u8]) -> IResult<bool> {
|
|
let original_input = input;
|
|
let (mut input, mut header) = RecordHeader::read(input)?;
|
|
while header.tag != Self::tag() {
|
|
(input, _) = take_bytes(input, header.data_size)?;
|
|
if header.tag == records::RTAG_ENDLIB {
|
|
return Ok((original_input, false))
|
|
}
|
|
(input, header) = RecordHeader::read(input)?;
|
|
}
|
|
(input, _) = take_bytes(input, header.data_size)?;
|
|
Ok((input, true))
|
|
}
|
|
|
|
fn skip_and_read(input: &[u8]) -> IResult<RData::BareData<'_>> {
|
|
let (mut input, mut header) = RecordHeader::read(input)?;
|
|
while header.tag != Self::tag() {
|
|
(input, _) = take_bytes(input, header.data_size)?;
|
|
(input, header) = RecordHeader::read(input)?;
|
|
}
|
|
let (input, data) = Self::read_data(input, header.data_size)?;
|
|
Ok((input, data))
|
|
}
|
|
|
|
fn expect_header(input: &[u8]) -> IResult<u16> {
|
|
let (input, header) = RecordHeader::read(input)?;
|
|
if header.tag != Self::tag() {
|
|
fail(input, format!("Unexpected record! Got tag 0x{:04x}, expected 0x{:04x}", header.tag, Self::tag()))
|
|
} else {
|
|
Ok((input, header.data_size))
|
|
}
|
|
}
|
|
|
|
fn read(input: &[u8]) -> IResult<RData::BareData<'_>> {
|
|
let (input, size) = Self::expect_header(input)?;
|
|
Self::check_size(size).unwrap();
|
|
let (input, data) = Self::read_data(input, size)?;
|
|
Ok((input, data))
|
|
}
|
|
|
|
fn write<W: Write>(ww: &mut W, data: &RData::InData) -> OResult {
|
|
let packed_data = RData::pack(data);
|
|
let data_bytes = packed_data.as_ref();
|
|
let len: u16 = data_bytes.len().try_into().expect("Record longer than max size (u16)!");
|
|
let mut size = 0;
|
|
size += Self::write_header(ww, len)?;
|
|
size += ww.write(data_bytes)?;
|
|
Ok(size)
|
|
}
|
|
}
|
|
|
|
pub struct BitArray;
|
|
impl RecordData for BitArray {
|
|
type BareData<'a> = [bool; 16];
|
|
type InData = [bool; 16];
|
|
type ByteData = [u8; 2];
|
|
|
|
fn read(input: &[u8], size: u16) -> IResult<Self::BareData<'_>> {
|
|
assert!(size == 2);
|
|
parse_bitarray(input)
|
|
}
|
|
|
|
fn pack_into(buf: &mut [u8], data: &Self::InData) {
|
|
pack_bitarray(buf, data);
|
|
}
|
|
|
|
fn pack(data: &Self::InData) -> Self::ByteData {
|
|
let mut buf = [0; 2];
|
|
Self::pack_into(&mut buf, data);
|
|
buf
|
|
}
|
|
}
|
|
|
|
|
|
pub struct Int2;
|
|
impl RecordData for Int2 {
|
|
type BareData<'a> = i16;
|
|
type InData = i16;
|
|
type ByteData = [u8; 2];
|
|
|
|
fn read(input: &[u8], size: u16) -> IResult<Self::BareData<'_>> {
|
|
assert!(size == 2);
|
|
parse_int2(input)
|
|
}
|
|
|
|
fn pack_into(buf: &mut [u8], data: &Self::InData) {
|
|
pack_int2(buf, *data)
|
|
}
|
|
|
|
fn pack(data: &Self::InData) -> Self::ByteData {
|
|
let mut buf = [0; 2];
|
|
Self::pack_into(&mut buf, data);
|
|
buf
|
|
}
|
|
}
|
|
|
|
pub struct Int4;
|
|
impl RecordData for Int4 {
|
|
type BareData<'a> = i32;
|
|
type InData = i32;
|
|
type ByteData = [u8; 4];
|
|
|
|
fn read(input: &[u8], size: u16) -> IResult<Self::BareData<'_>> {
|
|
assert!(size == 4);
|
|
parse_int4(input)
|
|
}
|
|
|
|
fn pack_into(buf: &mut [u8], data: &Self::InData) {
|
|
pack_int4(buf, *data)
|
|
}
|
|
|
|
fn pack(data: &Self::InData) -> Self::ByteData {
|
|
let mut buf = [0; 4];
|
|
Self::pack_into(&mut buf, data);
|
|
buf
|
|
}
|
|
}
|
|
|
|
|
|
pub struct Int2Array;
|
|
impl RecordData for Int2Array {
|
|
type BareData<'a> = Int2ArrayReader<'a>;
|
|
type InData = [i16];
|
|
type ByteData = Vec<u8>;
|
|
|
|
fn read(input: &[u8], size: u16) -> IResult<Self::BareData<'_>> {
|
|
assert!(size % 2 == 0, "Record must contain an integer quantity of integers");
|
|
//let mut input = input;
|
|
let (input, bytes) = take_bytes(input, size)?;
|
|
Ok((input, Int2ArrayReader{bytes}))
|
|
}
|
|
|
|
fn pack_into(buf: &mut [u8], data: &Self::InData) {
|
|
BigEndian::write_i16_into(data, buf)
|
|
}
|
|
|
|
fn pack(data: &Self::InData) -> Self::ByteData {
|
|
let mut buf = Vec::with_capacity(data.len() * 2);
|
|
Self::pack_into(&mut buf, data);
|
|
buf
|
|
}
|
|
}
|
|
|
|
pub struct Int2ArrayReader<'a> {
|
|
bytes: &'a [u8],
|
|
}
|
|
impl Iterator for Int2ArrayReader<'_> {
|
|
type Item = i16;
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
if self.bytes.len() < 2 {
|
|
None
|
|
} else {
|
|
let (remaining, val) = parse_int2(self.bytes).unwrap();
|
|
self.bytes = remaining;
|
|
Some(val)
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct Int4Array;
|
|
impl RecordData for Int4Array {
|
|
type BareData<'a> = Int4ArrayReader<'a>;
|
|
type InData = [i32];
|
|
type ByteData = Vec<u8>;
|
|
|
|
fn read(input: &[u8], size: u16) -> IResult<Self::BareData<'_>> {
|
|
assert!(size % 4 == 0, "Record must contain an integer quantity of integers");
|
|
//let mut input = input;
|
|
let (input, bytes) = take_bytes(input, size)?;
|
|
Ok((input, Int4ArrayReader{bytes}))
|
|
}
|
|
|
|
fn pack_into(buf: &mut [u8], data: &Self::InData) {
|
|
BigEndian::write_i32_into(data, buf)
|
|
}
|
|
|
|
fn pack(data: &Self::InData) -> Self::ByteData {
|
|
let mut buf = Vec::with_capacity(data.len() * 4);
|
|
Self::pack_into(&mut buf, data);
|
|
buf
|
|
}
|
|
}
|
|
|
|
pub struct Int4ArrayReader<'a> {
|
|
bytes: &'a [u8],
|
|
}
|
|
impl Iterator for Int4ArrayReader<'_> {
|
|
type Item = i32;
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
if self.bytes.len() < 4 {
|
|
None
|
|
} else {
|
|
let (remaining, val) = parse_int4(self.bytes).unwrap();
|
|
self.bytes = remaining;
|
|
Some(val)
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct Real8;
|
|
impl RecordData for Real8 {
|
|
type BareData<'a> = f64;
|
|
type InData = f64;
|
|
type ByteData = [u8; 8];
|
|
|
|
fn read(input: &[u8], size: u16) -> IResult<Self::BareData<'_>> {
|
|
assert!(size == 8);
|
|
parse_real8(input)
|
|
}
|
|
|
|
fn pack_into(buf: &mut [u8], data: &Self::InData) {
|
|
pack_real8(buf, *data).unwrap_or_else(|_| panic!("Float {0} too big for Real8", data))
|
|
}
|
|
|
|
fn pack(data: &Self::InData) -> Self::ByteData {
|
|
let mut buf = [0; 8];
|
|
Self::pack_into(&mut buf, data);
|
|
buf
|
|
}
|
|
}
|
|
|
|
pub struct Real8Pair;
|
|
impl RecordData for Real8Pair {
|
|
type BareData<'a> = (f64, f64);
|
|
type InData = (f64, f64);
|
|
type ByteData = [u8; 2 * 8];
|
|
|
|
fn read(input: &[u8], size: u16) -> IResult<Self::BareData<'_>> {
|
|
assert!(size == 2 * 8);
|
|
let (input, data0) = parse_real8(input)?;
|
|
let (input, data1) = parse_real8(input)?;
|
|
Ok((input, (data0, data1)))
|
|
}
|
|
|
|
fn pack_into(buf: &mut [u8], data: &Self::InData) {
|
|
pack_real8(&mut buf[8 * 0..], data.0).unwrap_or_else(|_| panic!("Float.0 {0} too big for Real8", data.0));
|
|
pack_real8(&mut buf[8 * 1..], data.1).unwrap_or_else(|_| panic!("Float.1 {0} too big for Real8", data.1));
|
|
}
|
|
|
|
fn pack(data: &Self::InData) -> Self::ByteData {
|
|
let mut buf = [0; 2 * 8];
|
|
Self::pack_into(&mut buf, data);
|
|
buf
|
|
}
|
|
|
|
//fn write<W: Write>(ww: &mut W, data: &Self::BareData) -> OResult {
|
|
// let mut buf = [u8; 2 * 6 * 2];
|
|
// Self::pack_into(&mut buf, data)
|
|
//}
|
|
}
|
|
|
|
pub struct ASCII;
|
|
impl RecordData for ASCII {
|
|
type BareData<'a> = Vec<u8>;
|
|
type InData = [u8];
|
|
type ByteData = Vec<u8>;
|
|
|
|
fn read(input: &[u8], size: u16) -> IResult<Self::BareData<'_>> {
|
|
parse_ascii(input, size)
|
|
}
|
|
|
|
fn pack_into(buf: &mut [u8], data: &Self::InData) {
|
|
pack_ascii(buf, data);
|
|
}
|
|
|
|
fn pack(data: &Self::InData) -> Self::ByteData {
|
|
let mut buf = Vec::with_capacity(data.len() * 4);
|
|
Self::pack_into(&mut buf, data);
|
|
buf
|
|
}
|
|
}
|
|
|
|
|
|
pub struct DateTimePair;
|
|
impl RecordData for DateTimePair {
|
|
type BareData<'a> = [[i16; 6]; 2];
|
|
type InData = [[i16; 6]; 2];
|
|
type ByteData = [u8; 2 * 6 * 2];
|
|
|
|
fn read(input: &[u8], size: u16) -> IResult<Self::BareData<'_>> {
|
|
assert!(size == 2 * 6 * 2);
|
|
let (input, data0) = parse_datetime(input)?;
|
|
let (input, data1) = parse_datetime(input)?;
|
|
Ok((input, [data0, data1]))
|
|
}
|
|
|
|
fn pack_into(buf: &mut [u8], data: &Self::InData) {
|
|
pack_datetime(&mut buf[6 * 2 * 0..], &data[0]);
|
|
pack_datetime(&mut buf[6 * 2 * 1..], &data[1]);
|
|
}
|
|
|
|
fn pack(data: &Self::InData) -> Self::ByteData {
|
|
let mut buf = [0; 2 * 6 * 2];
|
|
Self::pack_into(&mut buf, data);
|
|
buf
|
|
}
|
|
|
|
//fn write<W: Write>(ww: &mut W, data: &Self::BareData) -> OResult {
|
|
// let mut buf = [u8; 2 * 6 * 2];
|
|
// Self::pack_into(&mut buf, data)
|
|
//}
|
|
}
|
|
|
|
pub struct Empty;
|
|
impl RecordData for Empty {
|
|
type BareData<'a> = ();
|
|
type InData = ();
|
|
type ByteData = [u8; 0];
|
|
|
|
fn read(input: &[u8], size: u16) -> IResult<Self::BareData<'_>> {
|
|
assert!(size == 0);
|
|
Ok((input, ()))
|
|
}
|
|
|
|
fn pack_into(_buf: &mut [u8], _data: &Self::InData) {
|
|
}
|
|
|
|
fn pack(_data: &Self::InData) -> Self::ByteData {
|
|
[]
|
|
}
|
|
//fn write<W: Write>(ww: &mut W, data: &Self::BareData) {
|
|
//}
|
|
}
|