serialization 0.2.12

encode and decode your struct
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

#![feature(const_trait_impl)]
#![feature(generic_const_exprs)]
#![feature(specialization)]

use fastbuf::Buffer;
use serialization::{CompositeEncoder, Decode, Encode, Encoder, Serializable};
use serialization_minecraft::PacketDecoder;

pub struct TeestA {}

#[derive(Debug, Clone, Copy, Serializable)]
#[repr(u8)]
pub enum TestEnum {
    A(usize, usize) = 100,
    B = 102,
    C { value: i32 } = 105,
    D = 108,
    E = 134,
}

#[test]
fn testasdf() {
    let value = TestEnum::C { value: 123 };
    let mut buf = Buffer::<123>::new();
    let ref mut enc = serialization_minecraft::PacketEncoder::new(&mut buf);
    Encode::encode(&value, enc).unwrap();
    println!("{:?}", buf);
    let mut dec = PacketDecoder::new(&mut buf);
    let v: TestEnum = Decode::decode_placed(&mut dec).unwrap();
    println!("{v:?}");
}

pub struct TestStruct {
    v1: u8,
    v2: Option<TestStruct2>,
}

pub struct TestStruct2 {
    v1: u16,
    v2: u8,
    vec: Vec<u8>,
}

impl Encode for TestStruct {
    fn encode<E>(&self, encoder: &mut E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        let mut enc = encoder.encode_struct()?;
        enc.encode_element(&self.v1)?;
        enc.encode_element(&self.v2)?;
        enc.end()?;
        Ok(())
    }
}

impl Encode for TestStruct2 {
    fn encode<E>(&self, encoder: &mut E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        let mut enc = encoder.encode_struct()?;
        enc.encode_element(&self.v1)?;
        enc.encode_element(&self.v2)?;
        enc.encode_element(&self.vec)?;
        enc.end()?;
        Ok(())
    }
}

#[cfg(test)]
mod test {
    use crate::{TestStruct, TestStruct2};
    use fastbuf::{Buffer, ReadBuf};
    use serialization::Encode;

    #[test]
    fn test_struct() {
        let mut encoder = serialization_minecraft::PacketEncoder::new(Buffer::<255>::new());
        TestStruct {
            v1: 123,
            v2: Some(TestStruct2 {
                v1: 123,
                v2: 234,
                vec: vec![1, 2, 3],
            }),
        }
        .encode(&mut encoder)
        .unwrap();
        let data = [123, 1, 0, 123, 234, 3, 1, 2, 3];
        assert_eq!(encoder.get_continuous(data.len()), data);
    }
}

#[derive(Serializable)]
struct A {
    v1: u8,
    v2: u16,
}

#[derive(Serializable)]
struct B();

#[derive(Serializable)]
struct C(i32);