Serdine

Serdine 是一个微小的序列化库，用于以二进制、序列化格式反/序列化实例，侧重于易用性。

例如，当与属于 C 程序的数据文件接口时，这很方便，其中文件通常是内存中实例的镜像。

状态

该库目前被我的另一个项目（Catacomb II-64k）使用；我正在更新它，包括文档和新的功能。

设计和示例

该软件包提供对数字原语和数组的反/序列化实现，以小端格式；任何字段，特别是用户定义的类型字段，都可以使用自定义的反/序列化函数。反/序列化是递归的，因此任何类型都可以嵌套。

反/序列化特性非常简单

pub trait Serialize {
    fn serialize<W: Write>(&self, w: W) -> Result<(), std::io::Error>;
}

pub trait Deserialize {
    fn deserialize<R: Read>(r: R) -> Result<Self, std::io::Error>;
}

以下是一些反/序列化的示例

use serdine_derive::Deserialize;

#[derive(Deserialize)]
pub struct MyNamedFieldsStruct {
    pub my_i16: i16,
    pub my_u32: u32,
    pub my_f32: f32,
    pub my_f64: f64,
    pub my_arr: [u16; 2],
    pub my_bool: bool,
    #[deserialize = "deserialize_vec"]
    pub my_vec: Vec<u8>,
}

fn deserialize_vec<R: std::io::Read>(mut r: R) -> Result<Vec<u8>, std::io::Error> {
    let mut buffer = Vec::new();
    r.read_to_end(&mut buffer)?;
    Ok(buffer)
}

fn deserialize_named_fields_struct() {
    let serialized_bytes: &[u8] = &[
        0x80, 0x00,
        0xBE, 0xBA, 0xFE, 0xCA,
        0xC9, 0x3E, 0x7B, 0x44,
        0x0C, 0x07, 0x42, 0xB2, 0x80, 0x19, 0x24, 0x40,
        0x00, 0x01, 0x02, 0x03,
        0xCA,
        0x04, 0x05, 0x06
    ];

    let instance = MyNamedFieldsStruct::deserialize(serialized_bytes).unwrap();

    assert_eq!(0x80,                        instance.my_i16);
    assert_eq!(0xCAFEBABE,          instance.my_u32);
    assert_eq!(1004.981_f32,        instance.my_f32);
    assert_eq!(10.04981_f64,        instance.my_f64);
    assert_eq!([0x0100, 0x0302], instance.my_arr);
    assert_eq!(true,                          instance.my_bool);
    assert_eq!(vec![4, 5, 6],           instance.my_vec);
}

// Enums are supported, as long as they declare their representation.

#[derive(Serialize)]
#[repr(u16)]
enum MyEnum {
    VarA = 0,
    VarB = 1,
    VarC = 65534,
}

fn serialize_enum() {
    let mut serialized_instance = Vec::new();

    MyEnum::VarA.serialize(&mut serialized_instance).unwrap();
    MyEnum::VarC.serialize(&mut serialized_instance).unwrap();
    MyEnum::VarB.serialize(&mut serialized_instance).unwrap();

    let expected_bytes: &[u8] = &[
        0x00, 0x00,
        0xFE, 0xFF,
        0x01, 0x00,
    ];

    assert_eq!(expected_bytes, serialized_instance);
}