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

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

use std::{
    fmt,
    fs::File,
    hint::black_box,
    io::{Read, Write},
    mem::forget,
    str::FromStr,
};

use fastbuf::{Buf, Buffer, ReadBuf, WriteBuf};
use serialization::binary_format::SerialDescriptor;
use serialization_minecraft::{PacketDecoder, PacketEncoder};

#[derive(Debug, serialization::Serializable, PartialEq, PartialOrd, Ord, Eq, Clone)]
pub struct Log {
    pub address: Address,
    pub identity: String,
    pub userid: String,
    pub date: String,
    pub request: String,
    pub code: u16,
    pub size: u64,
}

// impl Drop for Log {
//     fn drop(&mut self) {
//         println!("log dropped");
//     }
// }

#[derive(Debug, serialization::Serializable, PartialEq, PartialOrd, Ord, Eq, Clone)]
pub struct Logs {
    pub logs: Vec<Log>,
}

#[derive(Debug, serialization::Serializable, PartialEq, PartialOrd, Ord, Eq, Clone, Copy)]
pub struct Address {
    pub x0: u8,
    pub x1: u8,
    pub x2: u8,
    pub x3: u8,
}

#[test]
fn testing() {
    type D = PacketDecoder<&'static mut Buffer<100>>;
    println!("logs {:?}", Logs::fields::<D>());
    println!("log {:?}", Log::fields::<D>());
    println!("address {:?}", Address::fields::<D>());
    for i in 0..10 {
        test_log();
    }
}

fn test_log() {
    const BUFFER_LEN: usize = 1024 * 1024 * 5000;
    let mut buf = unsafe { Box::<Buffer<BUFFER_LEN>>::new_zeroed().assume_init() };
    let value = Logs {
        logs: vec![
            Log {
                address: Address {
                    x0: 11,
                    x1: 22,
                    x2: 33,
                    x3: 44,
                },
                identity: String::from_str("ABCD").unwrap(),
                userid: String::from_str("ABCD").unwrap(),
                date: String::from_str("ABCD").unwrap(),
                request: String::from_str("ABCD").unwrap(),
                code: 55,
                size: 66,
            };
            10
        ],
    };
    let mut enc = PacketEncoder::new(&mut buf);
    serialization::Encode::encode(&value, &mut enc).unwrap();
    // let mut file = File::open("testtemp").unwrap();
    // let mut vec = Vec::new();
    // file.read_to_end(&mut vec).unwrap();
    // println!("veclen={:?}", vec.len());
    // WriteBuf::write(&mut buf, vec.as_slice());
    let buf_clone = buf.get_continuous(buf.remaining()).clone();
    for i in 0..10 {
        let mut buf = unsafe { Box::<Buffer<BUFFER_LEN>>::new_zeroed().assume_init() };
        WriteBuf::write(&mut buf, &buf_clone);
        let mut dec = serialization_minecraft::PacketDecoder::new(&mut buf);
        let decoded = <Logs as serialization::Decode>::decode_placed(&mut dec);
        let decoded = decoded.unwrap();
        unsafe { buf.set_pos(0) };

        black_box(&decoded);
    }
    //    println!("{:?}", decoded);
    drop(buf);
    std::mem::forget(value);
}