bevy_slinet 0.16.1

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

//! Implement the [`ReadOnlySerializer`] or [`MutableSerializer`] trait for serialzer and build it in config refer
//! BincodeSerializer to check how to do this.

use core::fmt::Debug;
use std::{
    error::Error,
    sync::{Arc, Mutex},
};

// Serializer trait defines the core functionality for serializing and deserializing packets,
// ensuring compatibility with multi-threaded contexts as it requires the Send and Sync bounds.
pub trait Serializer<ReceivingPacket, SendingPacket>: Send + Sync + 'static
where
    ReceivingPacket: Send + Sync + Debug + 'static,
    SendingPacket: Send + Sync + Debug + 'static,
{
    type EncodeError: Error + Send + Sync; // Error type for serialization/encoding operations
    type DecodeError: Error + Send + Sync; // Error type for deserialization/decoding operations

    // Serializes a packet into bytes to be sent over a network. The method takes ownership of the packet
    // and a peer address, returning either a byte vector or an error if serialization fails.
    fn serialize(&self, packet: SendingPacket) -> Result<Vec<u8>, Self::EncodeError>;
    // Deserializes bytes received from a network back into a packet structure.
    fn deserialize(&self, data: &[u8]) -> Result<ReceivingPacket, Self::DecodeError>;
}

// SerializerAdapter allows for flexibility in serializer implementation; supporting both immutable
// and mutable serialization strategies.
pub enum SerializerAdapter<ReceivingPacket, SendingPacket, EncErr, DecErr>
where
    EncErr: Error + Send + Sync,
    DecErr: Error + Send + Sync,
{
    ReadOnly(
        Arc<
            dyn ReadOnlySerializer<
                ReceivingPacket,
                SendingPacket,
                EncodeError = EncErr,
                DecodeError = DecErr,
            >,
        >,
    ),
    Mutable(
        Arc<
            Mutex<
                dyn MutableSerializer<
                    ReceivingPacket,
                    SendingPacket,
                    EncodeError = EncErr,
                    DecodeError = DecErr,
                >,
            >,
        >,
    ),
}

// Implementing Serializer for SerializerAdapter provides a concrete example of polymorphism,
// enabling different serialization strategies under the same interface.
impl<ReceivingPacket, SendingPacket, EncErr, DecErr> Serializer<ReceivingPacket, SendingPacket>
    for SerializerAdapter<ReceivingPacket, SendingPacket, EncErr, DecErr>
where
    SendingPacket: Send + Sync + Debug + 'static,
    ReceivingPacket: Send + Sync + Debug + 'static,
    EncErr: Error + Send + Sync + 'static,
    DecErr: Error + Send + Sync + 'static,
{
    type EncodeError = EncErr;
    type DecodeError = DecErr;

    // Depending on the adapter's type, serialization can either directly pass the data or
    // require locking a mutex to ensure thread-safety in mutable contexts.
    fn serialize(&self, packet: SendingPacket) -> Result<Vec<u8>, Self::EncodeError> {
        match self {
            SerializerAdapter::ReadOnly(serializer) => serializer.serialize(packet),
            SerializerAdapter::Mutable(serializer) => serializer.lock().unwrap().serialize(packet),
        }
    }

    // Deserialization behaves similarly to serialization, respecting the adapter's type.
    fn deserialize(&self, data: &[u8]) -> Result<ReceivingPacket, Self::DecodeError> {
        match self {
            SerializerAdapter::ReadOnly(serializer) => serializer.deserialize(data),
            SerializerAdapter::Mutable(serializer) => serializer.lock().unwrap().deserialize(data),
        }
    }
}

/// ReadOnlySerializer is designed for scenarios where the data structure does not change,
/// ensuring efficient and thread-safe operations without the overhead of locking mechanisms.
pub trait ReadOnlySerializer<ReceivingPacket, SendingPacket>: Send + Sync + 'static {
    type EncodeError: Error + Send + Sync;
    type DecodeError: Error + Send + Sync;
    fn serialize(&self, packet: SendingPacket) -> Result<Vec<u8>, Self::EncodeError>;
    fn deserialize(&self, buffer: &[u8]) -> Result<ReceivingPacket, Self::DecodeError>;
}
/// MutableSerializer supports scenarios where serialization state needs to be altered during operation,
/// useful in cases like cryptographic transformations where state is critical.
pub trait MutableSerializer<ReceivingPacket, SendingPacket>: Send + Sync + 'static {
    type EncodeError: Error + Send + Sync;
    type DecodeError: Error + Send + Sync;
    fn serialize(&mut self, p: SendingPacket) -> Result<Vec<u8>, Self::EncodeError>;
    fn deserialize(&mut self, buf: &[u8]) -> Result<ReceivingPacket, Self::DecodeError>;
}