#serialization #binary-encoding #writable #readable #framework #speedy #derive

persia-speedy-derive

一个快速的二进制序列化框架,支持#[derive(Readable, Writable)]

2个版本

0.7.3 2020年11月6日
0.7.2 2020年11月6日

#12 in #writable


2个crate中使用(通过persia-speedy

MIT/Apache

64KB
1.5K SLoC

一个快速的二进制序列化框架

Documentation

该crate的目标是提供快速、简单和易于使用的二进制序列化。

基准测试

请参阅rust_serialization_benchmark以获取基准测试。

示例

use std::borrow::Cow;
use speedy::{Readable, Writable, Endianness};

#[derive(PartialEq, Debug, Readable, Writable)]
enum Enum {
    A,
    B,
    C,
}

#[derive(PartialEq, Debug, Readable, Writable)]
struct Struct< 'a > {
    number: u64,
    string: String,
    vector: Vec< u8 >,
    cow: Cow< 'a, [i64] >,
    float: f32,
    enumeration: Enum
}

fn main() {
    let original = Struct {
        number: 0x12345678ABCDEF00,
        string: "A totally pointless string".to_owned(),
        vector: vec![ 1, 2, 3 ],
        cow: Cow::Borrowed( &[ 4, 5, 6 ] ),
        float: 3.1415,
        enumeration: Enum::C
    };

    let bytes = original.write_to_vec().unwrap();
    let deserialized: Struct =
        Struct::read_from_buffer( &bytes ).unwrap();

    assert_eq!( original, deserialized );
}

支持的类型

默认支持以下类型

类型 序列化形式
u8 原样
u16 原样
u32 原样
u64 原样
usize u64
i8 原样
i16 原样
i32 原样
i64 原样
f32 原样
f64 原样
bool u8,可以是 01
char u32
String {长度: u32,字节: [u8]}
Cow<'a', str> {长度: u32,字节: [u8]}
Vec<T> {长度: u32,: [T]}
Cow<'a', [T]> {长度: u32,: [T]}
HashMap<K, V> {长度: u32,: [K,V]}
BTreeMap<K, V> {长度: u32,: [K,V]}
HashSet<T> {长度: u32,: [T]}
BTreeSet<T> {长度: u32,: [T]}
Range<T> (T,T)
RangeInclusive<T> (T,T)
Option<T> (1_u8, T)0_u8
Result<T, E> (1_u8, T)(0_u8, E)
() nothing
(T) 原样
(T,T) 原样
(T, ..,T) 原样
enum枚举 {tag: u32,variant:T}
AtomicU8 u8
AtomicI8 i8
AtomicU16 u16
AtomicI16 i16
AtomicU32 u32
AtomicI32 i32
AtomicU64 u64
AtomicI64 i64
NonZeroU32 u32
std::net::Ipv4Addr u32
std::net::Ipv6Addr u128
std::net::IpAddr {is_ipv4: u8,: {u32u128}}
std::时间::Duration {: u64,subsec_nanos: u32}
std::时间::SystemTime std::time::DurationUNIX_EPOCH 以来
uuid::Uuid [u8; 16]

这些是稳定的,未来不会改变。

字段属性

#[speedy(长度= $expr)]

可以在大多数标准容器上使用来指定字段的长度。可以引用之前定义的任何字段。

例如

use speedy::{Readable, Writable};

#[derive(Readable, Writable)]
struct Struct {
    byte_count: u8,
    #[speedy(length = byte_count / 4)]
    data: Vec< u32 >
}

在序列化之前,您需要确保设置为 长度 的值与字段的 .len() 相等;如果不相等,则在尝试序列化时将得到错误。

设置此属性会按以下方式更改序列化格式

类型 序列化形式
Vec<T> [T]
Cow<'a', [T]> [T]
String [u8]
Cow<'a', str> [u8]
HashMap<K, V> [K,V]
BTreeMap<K, V> [K,V]
HashSet<T> [T]
BTreeSet<T> [T]

#[speedy(length_type= $ty)]

可以用来指定容器隐含长度字段的大小,无论它是在读取还是写入时。

可能的值

  • u7(与 u8 相同,但限制为 7 位,以兼容 u64_varint
  • u8
  • u16
  • u32(默认值)
  • u64_varint

#[speedy(varint)]

只能用于 u64 字段。强制字段以 varint 格式序列化。

#[speedy(skip)]

在读取和写入时跳过给定的字段。

#[speedy(default_on_eof)]

如果读取此字段时遇到 EOF,其值将设置为该类型的默认值,并忽略 EOF。

#[speedy(constant_prefix= $expr)]

指定一个静态字节字符串,该字符串将在给定字段之前写入或读取时存在。

枚举属性

#[speedy(tag_type= $ty)]

可以用来指定枚举标签的精确大小,无论它是在读取还是写入时。

可能的值

  • u7(与 u8 相同,但限制为 7 位,以兼容 u64_varint
  • u8
  • u16
  • u32(默认值)
  • u64_varint

#[speedy(peek_tag)]

带有此属性的枚举在从流中读取时不会消耗其标签值,在写入时也不会写入其自己的标签值。

枚举变体属性

#[speedy(tag= $expr)]

指定一个预设的标签值,用于给定的枚举变体。

许可证

根据您的选择,许可如下

贡献

除非您明确说明,否则您有意提交的任何贡献,根据 Apache-2.0 许可证的定义,都将作为上述双重许可,没有额外的条款或条件。

依赖

~1.5MB
~34K SLoC