bevy_slinet 0.16.0

A simple networking plugin for bevy.
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
106
107
108
109
110
111

//! A [`bincode`]-based packet serializer using native bincode traits.

use crate::serializer::ReadOnlySerializer;
pub use bincode::config;
use bincode::config::Configuration;

/// Bincode 2.x serializer using native Encode/Decode traits.
/// This provides the best performance without serde overhead.
///
/// For serde compatibility, use `BincodeSerdeSerializer` instead.
#[derive(Clone)]
pub struct BincodeSerializer {
    config: Configuration,
}

impl BincodeSerializer {
    pub fn new() -> Self {
        Self::default()
    }
}

impl Default for BincodeSerializer {
    fn default() -> Self {
        Self {
            config: bincode::config::standard(),
        }
    }
}

impl<ReceivingPacket, SendingPacket> ReadOnlySerializer<ReceivingPacket, SendingPacket>
    for BincodeSerializer
where
    ReceivingPacket: bincode::Decode<()>,
    SendingPacket: bincode::Encode,
{
    type EncodeError = bincode::error::EncodeError;
    type DecodeError = bincode::error::DecodeError;

    fn serialize(&self, t: SendingPacket) -> Result<Vec<u8>, Self::EncodeError> {
        bincode::encode_to_vec(&t, self.config)
    }

    fn deserialize(&self, bytes: &[u8]) -> Result<ReceivingPacket, Self::DecodeError> {
        bincode::decode_from_slice(bytes, self.config).map(|(packet, _len)| packet)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[derive(Clone, Debug, bincode::Decode, bincode::Encode, PartialEq)]
    struct TestPacket {
        id: u32,
        message: String,
    }

    #[test]
    fn test_serialize_deserialize_default() {
        let serializer = BincodeSerializer::default();
        let packet = TestPacket {
            id: 42,
            message: "Hello".to_string(),
        };

        let serialized =
            ReadOnlySerializer::<TestPacket, TestPacket>::serialize(&serializer, packet.clone())
                .unwrap();
        let deserialized: TestPacket =
            ReadOnlySerializer::<TestPacket, TestPacket>::deserialize(&serializer, &serialized)
                .unwrap();

        assert_eq!(packet, deserialized);
    }

    #[test]
    fn test_large_packet() {
        let serializer = BincodeSerializer::default();
        let packet = TestPacket {
            id: 999999,
            message: "A".repeat(10000),
        };

        let serialized =
            ReadOnlySerializer::<TestPacket, TestPacket>::serialize(&serializer, packet.clone())
                .unwrap();
        let deserialized: TestPacket =
            ReadOnlySerializer::<TestPacket, TestPacket>::deserialize(&serializer, &serialized)
                .unwrap();

        assert_eq!(packet, deserialized);
    }

    #[test]
    fn test_empty_string() {
        let serializer = BincodeSerializer::default();
        let packet = TestPacket {
            id: 0,
            message: String::new(),
        };

        let serialized =
            ReadOnlySerializer::<TestPacket, TestPacket>::serialize(&serializer, packet.clone())
                .unwrap();
        let deserialized: TestPacket =
            ReadOnlySerializer::<TestPacket, TestPacket>::deserialize(&serializer, &serialized)
                .unwrap();

        assert_eq!(packet, deserialized);
    }
}