#buffer #byte #string #pod

no-std watto

Utilities for parsing and serializing Plain Old Data

1 unstable release

0.1.0 Sep 12, 2022

#2008 in Algorithms

Download history 819/week @ 2023-10-14 692/week @ 2023-10-21 717/week @ 2023-10-28 731/week @ 2023-11-04 861/week @ 2023-11-11 1079/week @ 2023-11-18 968/week @ 2023-11-25 910/week @ 2023-12-02 1019/week @ 2023-12-09 964/week @ 2023-12-16 583/week @ 2023-12-23 876/week @ 2023-12-30 1448/week @ 2024-01-06 1847/week @ 2024-01-13 2196/week @ 2024-01-20 2523/week @ 2024-01-27

8,319 downloads per month
Used in 7 crates (4 directly)

Apache-2.0

17KB
212 lines

Watto

Build Status codecov

Utilities for parsing and serializing Plain Old Data.

Pod

The API is primarily defined on the [Pod] trait, which can be implemented for #[repr(C)] types. It is then possible to get a reference to that [Pod] or a slice thereof directly from an underlying buffer. Similarly, the [Pod] can also be turned into its underlying buffer as well, for example to write it out into an output buffer.

Features

writer: Exports an additional Writer wrapping a std::io::Write which allows explicitly aligning the output buffer by adding padding bytes.

strings: Exports a StringTable for serializing and reading deduplicated strings.

End-to-End Example

use std::mem;
use std::io::Write;

use watto::Pod;

/// Our format looks like this:
/// * A header, containing the number of `A`s.
/// * An aligned slice of `A`s (length given by the header)
/// * An aligned slice of `B`s (length implicitly given by end of buffer)
#[repr(C)]
struct Header {
    version: u32,
    num_as: u32,
}
unsafe impl Pod for Header {}

#[repr(C)]
#[derive(Debug, PartialEq)]
struct A(u16);
unsafe impl Pod for A {}

#[repr(C)]
#[derive(Debug, PartialEq)]
struct B(u64);
unsafe impl Pod for B {}

// Writing into an output buffer:
let mut writer = watto::Writer::new(vec![]);

writer.write_all(Header { version: 1, num_as: 3 }.as_bytes()).unwrap();
writer.align_to(mem::align_of::<A>()).unwrap();
writer.write_all(&[A(1), A(2), A(3)].as_bytes()).unwrap();
writer.align_to(mem::align_of::<B>()).unwrap();
writer.write_all(&[B(4), B(5), B(6)].as_bytes()).unwrap();

let buffer = writer.into_inner();

// Reading from a buffer:
let buffer = &buffer;

let (header, buffer) = Header::ref_from_prefix(buffer).unwrap();
let (_, buffer) = watto::align_to(buffer, mem::align_of::<A>()).unwrap();
let (r#as, buffer) = A::slice_from_prefix(buffer, header.num_as as usize).unwrap();
let (_, buffer) = watto::align_to(buffer, mem::align_of::<B>()).unwrap();
let bs = B::slice_from_bytes(buffer).unwrap();

assert_eq!(header.num_as, 3);
assert_eq!(r#as, &[A(1), A(2), A(3)]);
assert_eq!(bs, &[B(4), B(5), B(6)]);

Alternatives

Watto is strongly inspired by zerocopy.

Differences between the two include:

  • zerocopy has two distinct traits for reading and writing bytes, watto only has one for both.
  • In zerocopy, reading a value requires wrapping it in LayoutVerified. In watto, types implementing Pod can be read directly.
  • watto includes a Writer that allows explicit alignment of output.
  • watto includes a StringTable for (de)serializing strings.
  • zerocopy includes endianness-aware integer types.

Why Watto?

Qui-Gon Jinn: I have... acquired a pod in a game of chance. The fastest ever built.

Watto: I hope you didn't kill anyone I know for it.

-- Star Wars: Episode I - The Phantom Menace

License

Watto is licensed under the Apache-2.0 license.

Dependencies

~130KB