fefix 0.7.0

FIX & FAST (FIX Adapted for STreaming) in pure Rust.
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

use super::{Config, Configure, DecodeError, Decoder, RawDecoder, RawFrame};
use crate::{Dictionary, GetConfig};
use bytes::{Bytes, BytesMut};
use tokio_util::codec;

#[derive(Debug)]
pub struct TokioRawDecoder<C = Config> {
    dict: Dictionary,
    raw_decoder: RawDecoder<C>,
}

impl codec::Decoder for TokioRawDecoder {
    type Item = RawFrame<Bytes>;
    type Error = DecodeError;

    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
        let split = src.split();
        let result = self.raw_decoder.decode(split);
        match result {
            Ok(raw_frame) => Ok(Some(RawFrame {
                data: raw_frame.data.freeze(),
                begin_string: raw_frame.begin_string,
                payload: raw_frame.payload,
            })),
            Err(DecodeError::Invalid) => Ok(None),
            Err(e) => Err(e),
        }
    }
}

impl<C> GetConfig for TokioRawDecoder<C> {
    type Config = C;

    fn config(&self) -> &Self::Config {
        self.raw_decoder.config()
    }

    fn config_mut(&mut self) -> &mut Self::Config {
        self.raw_decoder.config_mut()
    }
}

#[derive(Debug)]
#[cfg_attr(doc_cfg, doc(cfg(feature = "utils-tokio")))]
pub struct TokioDecoder<C = Config>
where
    C: Configure,
{
    dict: Dictionary,
    raw_decoder: Decoder<C>,
}

//impl codec::Decoder for TokioDecoder {
//    type Item = Message;
//    type Error = DecodeError;
//
//    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
//        let split = src.split();
//        let result = self.raw_decoder.decode(split);
//        match result {
//            Ok(raw_frame) => Ok(Some(raw_frame.map_data(|bytes_mut| bytes_mut.freeze()))),
//            Err(DecodeError::Invalid) => Ok(None),
//            Err(e) => Err(e),
//        }
//    }
//}