Crate rkyv_codec

This crate provides zero-copy deserialization for packet streaming using rkyv. Simple usage example:

use rkyv::{Archived, util::AlignedVec, Archive, Serialize, Deserialize, rancor};
use rkyv_codec::{archive_stream, RkyvWriter, VarintLength};
use futures::SinkExt;
#[derive(Archive, Deserialize, Serialize, Debug, PartialEq, Clone)]
#[rkyv(derive(Debug), compare(PartialEq))]
struct Test {
    int: u8,
    string: String,
    option: Option<Vec<i32>>,
}
let value = Test {
    int: 42,
    string: "hello world".to_string(),
    option: Some(vec![1, 2, 3, 4]),
};
// Writing
let writer = Vec::new();
let mut codec = RkyvWriter::<_, VarintLength>::new(writer);
codec.send(&value).await.unwrap();
// Reading
let mut reader = &codec.inner()[..];
let mut buffer = AlignedVec::new(); // Aligned streaming buffer for re-use
let value_archived: &Archived<Test> = archive_stream::<_, Test, VarintLength>(&mut reader, &mut buffer).await.unwrap(); // This returns a reference into the passed buffer
// can deserialize as normal as well (or do *partial* deserialization for blazingly fast speeds!)
let value_deserialized: Test = rkyv::deserialize::<_, rancor::Error>(value_archived).unwrap();
assert_eq!(value, *value_archived);
assert_eq!(value, value_deserialized);

Structs

RkyvCodec

A futures-compatible Codec using the asynchronous-codec library.

RkyvWriter

Wraps an AsyncWrite and implements Sink to serialize Archive objects.

U8Length

Big-endian fixed-size integer length encoding.

U16Length

Big-endian fixed-size integer length encoding.

U32Length

Big-endian fixed-size integer length encoding.

U64Length

Big-endian fixed-size integer length encoding.

VarintLength

Variable-bit length encoding based using unsigned_varint crate, currently can handle lengths up to 2^63

Enums

RkyvCodecError

Traits

LengthCodec

Length encoding trait, allows for different kinds of length encoding

Functions

archive_sink

Rewrites a single buffer representing an Archive to an AsyncWrite

archive_sink_bytes

Writes a single Object from a bytes::Bytes

archive_stream

Reads a single &Archived<Object> from an AsyncRead using the passed buffer.

archive_stream_bytes

Reads a single &Archived<Object> from a bytes::Bytes into the passed buffer if validation enabled.

archive_stream_bytes_unsafe^⚠

Reads a single &Archived<Object> from a bytes::Bytes into the passed buffer

archive_stream_unsafe^⚠

Reads a single &Archived<Object> from an AsyncRead without checking for correct byte formatting