#序列化 #二进制编码 #speedy #可写入 #可读 #框架 #派生

speedy-derive

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

16个版本

0.8.7 2024年1月14日
0.8.6 2023年3月20日
0.8.5 2022年11月14日
0.8.0 2021年8月17日
0.3.0 2017年12月11日

9#speedy 中排名

Download history 2208/week @ 2024-04-08 2326/week @ 2024-04-15 2123/week @ 2024-04-22 2050/week @ 2024-04-29 2302/week @ 2024-05-06 1801/week @ 2024-05-13 1738/week @ 2024-05-20 1298/week @ 2024-05-27 1938/week @ 2024-06-03 1821/week @ 2024-06-10 1587/week @ 2024-06-17 1787/week @ 2024-06-24 1807/week @ 2024-07-01 2293/week @ 2024-07-08 2999/week @ 2024-07-15 2265/week @ 2024-07-22

9,536 每月下载量
用于 51 个crate (2 直接)

MIT/Apache

93KB
2K 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, T)
Result<T, E> (1_u8, T)(0_u8, E)
()
(T) 原样
(T,T) 原样
(T, ..,T) 原样
enum枚举 {标签: u32,变体: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::时间::持续时间 {: u64,子秒纳秒: u32}
std::时间::系统时间 std::time::DurationUNIX_EPOCH
uuid::Uuid [u8; 16]

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

字段属性

#[快速(长度= $expr)]

可用于大多数标准容器,以指定字段的长度。可以引用任何之前的字段。

例如

use speedy::{Readable, Writable};

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

在序列化之前,您需要确保设置为 length 的内容等于该字段的 .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]

#[快速(length_type= $ty)]

可用于指定容器隐式长度字段的精确大小,当读取或写入时。

可能值

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

#[快速(varint)]

只能用于 u64 字段。强制字段按 varint 序列化。

#[快速(skip)]

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

#[快速(default_on_eof)]

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

#[快速(constant_prefix= $expr)]

指定在给定字段之前写入或读取之前必须存在的静态字节字符串。

枚举属性

#[快速(tag_type= $ty)]

可用于指定枚举的标签在读取或写入时的精确大小。

可能值

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

#[快速(peek_tag)]

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

枚举变体属性

#[快速(标签= $expr)]

指定用于给定枚举变体的预置标签值。

许可协议

根据您的选择许可

贡献

除非您明确表示,否则根据 Apache-2.0 许可证定义的,您有意提交的任何贡献,都应如上所述双重许可,没有任何附加条款或条件。

依赖关系

~275–730KB
~17K SLoC