pheon/src/record.rs

466 lines
13 KiB
Rust
Raw Permalink Normal View History

///
/// Generic record-level read/write functionality.
///
use std::io::{self, Write};
use crate::basic::{pack_datetime, pack_bitarray, pack_ascii, pack_int2, pack_int4, pack_real8};
use crate::basic::{parse_datetime, parse_bitarray, parse_ascii, parse_int2, parse_int4, parse_real8};
use crate::basic::{ErrType, IResult, OResult, fail, incomplete, take_bytes};
use crate::records;
#[repr(C)]
#[derive(Debug, Clone)]
pub struct RecordHeader {
pub tag: u16,
pub data_size: u16,
}
impl RecordHeader {
pub fn read(input: &[u8]) -> IResult<'_, RecordHeader> {
let Some((&[size_hi, size_lo, tag_hi, tag_lo], payload)) = input.split_first_chunk::<4>() else {
return incomplete(input, Some(4));
};
let size = u16::from_be_bytes([size_hi, size_lo]);
let Some(data_size) = size.checked_sub(4) else {
return fail(input, format!("Record size {size} is smaller than its header"));
};
let tag = u16::from_be_bytes([tag_hi, tag_lo]);
Ok((payload, RecordHeader { tag, data_size }))
}
pub fn pack_into(&self) -> io::Result<[u8; 4]> {
let size = self.data_size.checked_add(4)
.ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "Record longer than max size (u16)"))?;
let [size_hi, size_lo] = size.to_be_bytes();
let [tag_hi, tag_lo] = self.tag.to_be_bytes();
Ok([size_hi, size_lo, tag_hi, tag_lo])
}
pub fn write<W: Write>(&self, ww: &mut W) -> OResult {
let bytes = self.pack_into()?;
ww.write_all(&bytes)?;
Ok(bytes.len())
}
}
/// A complete record borrowing its payload from the input.
pub(crate) struct RecordFrame<'a> {
pub tag: u16,
pub data: &'a [u8],
}
impl<'a> RecordFrame<'a> {
pub fn read(input: &'a [u8]) -> IResult<'a, Self> {
let (_, header) = RecordHeader::read(input)?;
let (remaining, data) = read_payload(input, header.data_size)?;
Ok((remaining, Self { tag: header.tag, data }))
}
/// Decode the payload after the caller has matched the record tag.
pub fn decode<R: Record<D> + ?Sized, D: RecordData>(
&self,
) -> Result<D::BareData<'a>, (&'a [u8], ErrType)> {
let (_, value) = R::read_data(self.data, self.data.len() as u16)?;
Ok(value)
}
}
fn read_payload(input: &[u8], size: u16) -> IResult<'_, &[u8]> {
if !size.is_multiple_of(2) {
return fail(input, "odd record length".to_string());
}
let Some((record, remaining)) = input.split_at_checked(4 + usize::from(size)) else {
return fail(input, "truncated record".to_string());
};
Ok((remaining, &record[4..]))
}
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 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 write_header<W: Write>(ww: &mut W, data_size: u16) -> OResult {
Self::check_size(data_size)
.map_err(|message| io::Error::new(io::ErrorKind::InvalidInput, message))?;
RecordHeader{tag: Self::tag(), data_size}.write(ww)
}
fn read_data(input: &[u8], size: u16) -> IResult<'_, RData::BareData<'_>> {
if let Err(message) = Self::check_size(size) {
return fail(input, message);
}
RData::read(input, size)
}
///
/// 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 = input;
loop {
let (remaining, record) = RecordFrame::read(input)?;
if record.tag == Self::tag() {
return Ok((remaining, true));
}
if record.tag == records::RTAG_ENDLIB {
return Ok((original_input, false));
}
input = remaining;
}
}
fn skip_and_read(input: &[u8]) -> IResult<'_, RData::BareData<'_>> {
let mut input = input;
loop {
let (remaining, record) = RecordFrame::read(input)?;
if record.tag == Self::tag() {
return Ok((remaining, record.decode::<Self, RData>()?));
}
input = remaining;
}
}
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 (_, size) = Self::expect_header(input)?;
let (remaining, data) = read_payload(input, size)?;
let (_, value) = Self::read_data(data, size)?;
Ok((remaining, value))
}
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::try_from(data_bytes.len())
.map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "Record longer than max size (u16)"))?;
Self::write_header(ww, len)?;
ww.write_all(data_bytes)?;
Ok(usize::from(len) + 4)
}
}
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<'_>> {
if size != 2 {
return fail(input, format!("Expected record size {}, got {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<'_>> {
if size != 2 {
return fail(input, format!("Expected record size {}, got {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<'_>> {
if size != 4 {
return fail(input, format!("Expected record size {}, got {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<'_>> {
if !size.is_multiple_of(2) {
return fail(input, format!("Record size must be divisible by 2, got {size}"));
}
let (input, bytes) = take_bytes(input, size)?;
Ok((input, Int2ArrayReader{bytes}))
}
fn pack_into(buf: &mut [u8], data: &Self::InData) {
assert_eq!(buf.len(), data.len() * 2);
for (bytes, value) in buf.as_chunks_mut::<2>().0.iter_mut().zip(data) {
*bytes = value.to_be_bytes();
}
}
fn pack(data: &Self::InData) -> Self::ByteData {
let mut buf = vec![0; 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<'_>> {
if !size.is_multiple_of(4) {
return fail(input, format!("Record size must be divisible by 4, got {size}"));
}
let (input, bytes) = take_bytes(input, size)?;
Ok((input, Int4ArrayReader{bytes}))
}
fn pack_into(buf: &mut [u8], data: &Self::InData) {
assert_eq!(buf.len(), data.len() * 4);
for (bytes, value) in buf.as_chunks_mut::<4>().0.iter_mut().zip(data) {
*bytes = value.to_be_bytes();
}
}
fn pack(data: &Self::InData) -> Self::ByteData {
let mut buf = vec![0; 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<'_>> {
if size != 8 {
return fail(input, format!("Expected record size {}, got {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<'_>> {
if size != 2 * 8 {
return fail(input, format!("Expected record size {}, got {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(buf, 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
}
}
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![0; data.len() + data.len() % 2];
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<'_>> {
if size != 2 * 6 * 2 {
return fail(input, format!("Expected record size {}, got {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(buf, &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
}
}
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<'_>> {
if size != 0 {
return fail(input, format!("Expected record size {}, got {size}", 0));
}
Ok((input, ()))
}
fn pack_into(_buf: &mut [u8], _data: &Self::InData) {
}
fn pack(_data: &Self::InData) -> Self::ByteData {
[]
}
}