vyre 0.1.0

GPU bytecode condition engine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

use crate::error::{Error, Result};

const MAGIC: [u8; 8] = *b"VYREPART";

/// Frame multiple byte slices into a single blob with length prefixes.
pub fn encode_parts(parts: &[&[u8]]) -> Vec<u8> {
    let total = MAGIC.len() + parts.iter().map(|part| 8 + part.len()).sum::<usize>();
    let mut out = Vec::with_capacity(total);
    out.extend_from_slice(&MAGIC);
    for part in parts {
        out.extend_from_slice(&(part.len() as u64).to_le_bytes());
        out.extend_from_slice(part);
    }
    out
}

/// Decode a blob produced by [`encode_parts`].
pub fn decode_parts(mut bytes: &[u8]) -> Result<Vec<&[u8]>> {
    if bytes.len() < MAGIC.len() || bytes[..MAGIC.len()] != MAGIC {
        return Err(Error::Gpu {
            message: "invalid vyre serializer header".to_string(),
        });
    }
    bytes = &bytes[MAGIC.len()..];
    let mut parts = Vec::new();
    while !bytes.is_empty() {
        if bytes.len() < 8 {
            return Err(Error::Gpu {
                message: "truncated framed part length".to_string(),
            });
        }
        let len = u64::from_le_bytes(bytes[..8].try_into().map_err(|_| Error::Gpu {
            message: "invalid framed part length".to_string(),
        })?) as usize;
        bytes = &bytes[8..];
        if bytes.len() < len {
            return Err(Error::Gpu {
                message: "truncated framed part payload".to_string(),
            });
        }
        let (part, rest) = bytes.split_at(len);
        parts.push(part);
        bytes = rest;
    }
    Ok(parts)
}