nmr 0.1.2

NMR data tools for Rust
Documentation
use super::{
    SnapshotError,
    wire::{Budget, Value},
};
use crate::{Complex64, ExecutionContext};
use sha2::{Digest, Sha256};
use std::{
    borrow::Cow,
    io::{Read, Write},
};

const BLOCK: usize = 4096;
const MAGIC: &[u8; 8] = b"NMRSS001";
const COMMIT: &[u8; 8] = b"NMRDONE1";

pub(super) fn size(
    value: &Value<'_>,
    control: &mut ExecutionContext<'_>,
    depth: usize,
    max_depth: usize,
) -> Result<u64, SnapshotError> {
    control.check_cancelled()?;
    if depth > max_depth.min(256) {
        return Err(SnapshotError::ResourceLimit);
    }
    let result = match value {
        Value::Record(tag, fields) => {
            fields
                .iter()
                .try_fold(17u64 + tag.len() as u64, |total, field| {
                    total
                        .checked_add(size(field, control, depth + 1, max_depth)?)
                        .ok_or(SnapshotError::SizeOverflow)
                })?
        }
        Value::Sequence(fields) => fields.iter().try_fold(9u64, |total, field| {
            total
                .checked_add(size(field, control, depth + 1, max_depth)?)
                .ok_or(SnapshotError::SizeOverflow)
        })?,
        Value::Text(v) => 9 + v.len() as u64,
        Value::Bytes(v) => 9 + v.len() as u64,
        Value::Unsigned(_) | Value::Signed(_) | Value::Float(_) => 9,
        Value::Boolean(_) => 2,
        Value::Floats(v) => numeric_size(v.len(), 8)?,
        Value::Complexes(v) => numeric_size(v.len(), 16)?,
    };
    Ok(result)
}
fn numeric_size(count: usize, width: u64) -> Result<u64, SnapshotError> {
    (count as u64)
        .checked_mul(width)
        .and_then(|n| n.checked_add(9 + 4 * count.div_ceil(BLOCK) as u64))
        .ok_or(SnapshotError::SizeOverflow)
}

pub(super) fn write(
    writer: &mut impl Write,
    value: &Value<'_>,
    length: u64,
    control: &mut ExecutionContext<'_>,
) -> Result<(), SnapshotError> {
    let mut header = Vec::from(MAGIC.as_slice());
    header.extend_from_slice(&1u32.to_le_bytes());
    header.extend_from_slice(&length.to_le_bytes());
    let mut out = Encoder {
        writer,
        control,
        digest: Sha256::new(),
    };
    out.bytes(&header)?;
    out.value(value)?;
    let hash = out.digest.clone().finalize();
    out.bytes(&hash)?;
    out.bytes(COMMIT)?;
    Ok(())
}
struct Encoder<'a, 'ctx, W> {
    writer: &'a mut W,
    control: &'a mut ExecutionContext<'ctx>,
    digest: Sha256,
}
impl<W: Write> Encoder<'_, '_, W> {
    fn bytes(&mut self, bytes: &[u8]) -> Result<(), SnapshotError> {
        for block in bytes.chunks(32768) {
            self.control.check_cancelled()?;
            self.writer.write_all(block)?;
            self.digest.update(block);
            self.control.io(block.len())?;
        }
        Ok(())
    }
    fn count(&mut self, n: usize) -> Result<(), SnapshotError> {
        self.bytes(&(n as u64).to_le_bytes())
    }
    fn text(&mut self, s: &str) -> Result<(), SnapshotError> {
        self.count(s.len())?;
        self.bytes(s.as_bytes())
    }
    #[inline(never)]
    fn floats(&mut self, v: &[f64]) -> Result<(), SnapshotError> {
        self.bytes(&[8])?;
        self.count(v.len())?;
        let mut buffer = [0u8; BLOCK * 8];
        for chunk in v.chunks(BLOCK) {
            self.bytes(&(chunk.len() as u32).to_le_bytes())?;
            for (value, bytes) in chunk.iter().zip(buffer.chunks_exact_mut(8)) {
                bytes.copy_from_slice(&value.to_bits().to_le_bytes());
            }
            self.bytes(&buffer[..chunk.len() * 8])?;
        }
        Ok(())
    }
    #[inline(never)]
    fn complexes(&mut self, v: &[Complex64]) -> Result<(), SnapshotError> {
        self.bytes(&[9])?;
        self.count(v.len())?;
        let mut buffer = [0u8; BLOCK * 16];
        for chunk in v.chunks(BLOCK) {
            self.bytes(&(chunk.len() as u32).to_le_bytes())?;
            for (value, bytes) in chunk.iter().zip(buffer.chunks_exact_mut(16)) {
                bytes[..8].copy_from_slice(&value.re.to_bits().to_le_bytes());
                bytes[8..].copy_from_slice(&value.im.to_bits().to_le_bytes());
            }
            self.bytes(&buffer[..chunk.len() * 16])?;
        }
        Ok(())
    }
    fn value(&mut self, value: &Value<'_>) -> Result<(), SnapshotError> {
        match value {
            Value::Record(tag, fields) => {
                self.bytes(&[0])?;
                self.text(tag)?;
                self.count(fields.len())?;
                for field in fields {
                    self.value(field)?;
                }
            }
            Value::Sequence(fields) => {
                self.bytes(&[1])?;
                self.count(fields.len())?;
                for field in fields {
                    self.value(field)?;
                }
            }
            Value::Text(v) => {
                self.bytes(&[2])?;
                self.text(v)?;
            }
            Value::Unsigned(v) => {
                self.bytes(&[3])?;
                self.bytes(&v.to_le_bytes())?;
            }
            Value::Signed(v) => {
                self.bytes(&[4])?;
                self.bytes(&v.to_le_bytes())?;
            }
            Value::Float(v) => {
                self.bytes(&[5])?;
                self.bytes(&v.to_le_bytes())?;
            }
            Value::Boolean(v) => self.bytes(&[6, u8::from(*v)])?,
            Value::Bytes(v) => {
                self.bytes(&[7])?;
                self.count(v.len())?;
                self.bytes(v)?;
            }
            Value::Floats(v) => self.floats(v)?,
            Value::Complexes(v) => self.complexes(v)?,
        };
        Ok(())
    }
}

pub(super) fn read(
    reader: &mut impl Read,
    budget: &mut Budget<'_, '_>,
) -> Result<Value<'static>, SnapshotError> {
    let mut header = [0u8; 20];
    read_exact(reader, &mut header, budget.control)?;
    if &header[..8] != MAGIC {
        return Err(SnapshotError::Structure);
    }
    let version = u32::from_le_bytes(header[8..12].try_into().expect("fixed header"));
    if version != 1 {
        return Err(SnapshotError::UnsupportedVersion(version));
    }
    let length = u64::from_le_bytes(header[12..20].try_into().expect("fixed header"));
    if length
        .checked_add(60)
        .is_none_or(|n| n > budget.limits.max_bytes)
    {
        return Err(SnapshotError::ResourceLimit);
    }
    let mut digest = Sha256::new();
    digest.update(header);
    let mut decoder = Decoder {
        reader,
        remaining: length,
        digest,
        budget,
    };
    let value = decoder.value(0)?;
    if decoder.remaining != 0 {
        return Err(SnapshotError::Structure);
    }
    let expected = decoder.digest.finalize();
    let mut trailer = [0u8; 40];
    read_exact(decoder.reader, &mut trailer, decoder.budget.control)?;
    if trailer[..32] != expected[..] || &trailer[32..] != COMMIT {
        return Err(SnapshotError::Integrity);
    }
    Ok(value)
}
fn read_exact(
    reader: &mut impl Read,
    buffer: &mut [u8],
    control: &mut ExecutionContext<'_>,
) -> Result<(), SnapshotError> {
    for block in buffer.chunks_mut(32768) {
        let mut filled = 0;
        while filled < block.len() {
            control.check_cancelled()?;
            match reader.read(&mut block[filled..]) {
                Ok(0) => return Err(SnapshotError::Truncated),
                Ok(n) => {
                    filled += n;
                    control.io(n)?;
                }
                Err(e) if e.kind() == std::io::ErrorKind::Interrupted => {}
                Err(e) => return Err(e.into()),
            }
        }
    }
    Ok(())
}
struct Decoder<'a, 'b, 'ctx, R> {
    reader: &'a mut R,
    remaining: u64,
    digest: Sha256,
    budget: &'a mut Budget<'b, 'ctx>,
}
impl<R: Read> Decoder<'_, '_, '_, R> {
    fn bytes(&mut self, bytes: &mut [u8]) -> Result<(), SnapshotError> {
        if bytes.len() as u64 > self.remaining {
            return Err(SnapshotError::Truncated);
        }
        read_exact(self.reader, bytes, self.budget.control)?;
        self.remaining -= bytes.len() as u64;
        self.digest.update(bytes);
        Ok(())
    }
    fn number(&mut self) -> Result<u64, SnapshotError> {
        let mut b = [0; 8];
        self.bytes(&mut b)?;
        Ok(u64::from_le_bytes(b))
    }
    fn count(&mut self, width: usize) -> Result<usize, SnapshotError> {
        let n = usize::try_from(self.number()?).map_err(|_| SnapshotError::SizeOverflow)?;
        let bytes = n.checked_mul(width).ok_or(SnapshotError::SizeOverflow)?;
        if bytes as u64 > self.remaining {
            return Err(SnapshotError::Truncated);
        }
        Ok(n)
    }
    fn string(&mut self) -> Result<String, SnapshotError> {
        let n = self.count(1)?;
        self.budget.reserve::<u8>(n)?;
        let mut b = allocated(n)?;
        b.resize(n, 0);
        self.bytes(&mut b)?;
        String::from_utf8(b).map_err(|_| SnapshotError::Structure)
    }
    fn children(&mut self, depth: usize) -> Result<Vec<Value<'static>>, SnapshotError> {
        let n = self.count(1)?;
        self.budget.reserve::<Value<'_>>(n)?;
        let mut values = allocated(n)?;
        for _ in 0..n {
            values.push(self.value(depth + 1)?);
        }
        Ok(values)
    }
    #[inline(never)]
    fn numeric(&mut self, width: usize) -> Result<Value<'static>, SnapshotError> {
        let n = self.count(width)?;
        self.budget
            .samples(n.checked_mul(width).ok_or(SnapshotError::SizeOverflow)?)?;
        let mut reals = if width == 8 {
            allocated(n)?
        } else {
            Vec::new()
        };
        let mut complexes = if width == 16 {
            allocated(n)?
        } else {
            Vec::new()
        };
        let mut remaining = n;
        let mut buffer = [0u8; BLOCK * 16];
        while remaining != 0 {
            let mut chunk = [0; 4];
            self.bytes(&mut chunk)?;
            let count = u32::from_le_bytes(chunk) as usize;
            if count == 0 || count > BLOCK || count > remaining {
                return Err(SnapshotError::Structure);
            }
            self.bytes(&mut buffer[..count * width])?;
            for point in buffer[..count * width].chunks_exact(width) {
                let re =
                    f64::from_bits(u64::from_le_bytes(point[..8].try_into().expect("binary64")));
                if width == 8 {
                    reals.push(re)
                } else {
                    let im = f64::from_bits(u64::from_le_bytes(
                        point[8..].try_into().expect("binary64"),
                    ));
                    complexes.push(Complex64::new(re, im));
                }
            }
            remaining -= count;
        }
        Ok(if width == 8 {
            Value::Floats(Cow::Owned(reals))
        } else {
            Value::Complexes(Cow::Owned(complexes))
        })
    }
    fn value(&mut self, depth: usize) -> Result<Value<'static>, SnapshotError> {
        self.budget.control.check_cancelled()?;
        if depth > self.budget.limits.max_depth.min(256) {
            return Err(SnapshotError::ResourceLimit);
        }
        let mut tag = [0];
        self.bytes(&mut tag)?;
        Ok(match tag[0] {
            0 => {
                let tag = self.string()?;
                Value::Record(Cow::Owned(tag), self.children(depth)?)
            }
            1 => Value::Sequence(self.children(depth)?),
            2 => Value::Text(Cow::Owned(self.string()?)),
            3 => Value::Unsigned(self.number()?),
            4 => Value::Signed(self.number()? as i64),
            5 => Value::Float(self.number()?),
            6 => {
                let mut b = [0];
                self.bytes(&mut b)?;
                if b[0] > 1 {
                    return Err(SnapshotError::Structure);
                }
                Value::Boolean(b[0] == 1)
            }
            7 => {
                let n = self.count(1)?;
                self.budget.reserve::<u8>(n)?;
                let mut b = allocated(n)?;
                b.resize(n, 0);
                self.bytes(&mut b)?;
                Value::Bytes(Cow::Owned(b))
            }
            8 | 9 => self.numeric(if tag[0] == 8 { 8 } else { 16 })?,

            _ => return Err(SnapshotError::Structure),
        })
    }
}
fn allocated<T>(n: usize) -> Result<Vec<T>, SnapshotError> {
    let mut v = Vec::new();
    v.try_reserve_exact(n)
        .map_err(|_| SnapshotError::Allocation)?;
    Ok(v)
}