volans-codec 0.2.1

Codec for Volans networking framework
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

mod json;
mod protobuf;

pub use json::JsonUviCodec;
pub use protobuf::ProtobufUviCodec;

pub use asynchronous_codec::*;
pub use prost;

pub struct CombinedCodec<TEncoder, TDecoder>
where
    TEncoder: Encoder,
    TDecoder: Decoder,
{
    encoder: TEncoder,
    decoder: TDecoder,
}

impl<TEncoder, TDecoder> Encoder for CombinedCodec<TEncoder, TDecoder>
where
    TEncoder: Encoder,
    TDecoder: Decoder,
{
    type Item<'a> = TEncoder::Item<'a>;
    type Error = TEncoder::Error;

    fn encode(&mut self, item: Self::Item<'_>, dst: &mut BytesMut) -> Result<(), Self::Error> {
        self.encoder.encode(item, dst)
    }
}

impl<TEncoder, TDecoder> Decoder for CombinedCodec<TEncoder, TDecoder>
where
    TEncoder: Encoder,
    TDecoder: Decoder,
{
    type Item = TDecoder::Item;
    type Error = TDecoder::Error;

    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
        self.decoder.decode(src)
    }
}

impl<TEncoder, TDecoder> Clone for CombinedCodec<TEncoder, TDecoder>
where
    TEncoder: Encoder + Clone,
    TDecoder: Decoder + Clone,
{
    fn clone(&self) -> Self {
        CombinedCodec {
            encoder: self.encoder.clone(),
            decoder: self.decoder.clone(),
        }
    }
}

impl<TEncoder, TDecoder> Default for CombinedCodec<TEncoder, TDecoder>
where
    TEncoder: Encoder + Default,
    TDecoder: Decoder + Default,
{
    fn default() -> Self {
        CombinedCodec {
            encoder: TEncoder::default(),
            decoder: TDecoder::default(),
        }
    }
}

impl<TEncoder, TDecoder> CombinedCodec<TEncoder, TDecoder>
where
    TEncoder: Encoder,
    TDecoder: Decoder,
{
    pub fn new(encoder: TEncoder, decoder: TDecoder) -> Self {
        CombinedCodec { encoder, decoder }
    }

    pub fn encoder(&self) -> &TEncoder {
        &self.encoder
    }

    pub fn decoder(&self) -> &TDecoder {
        &self.decoder
    }

    pub fn encoder_mut(&mut self) -> &mut TEncoder {
        &mut self.encoder
    }

    pub fn decoder_mut(&mut self) -> &mut TDecoder {
        &mut self.decoder
    }
}