bytecon 0.5.13

A trait for easily converting to-and-from an array of bytes.
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use std::error::Error;
use tokio::{io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt}, net::TcpStream};
use tokio_rustls::TlsStream;
use crate::{ByteConverter, ByteStreamReaderAsync, ByteStreamWriterAsync};

#[inline(always)]
async fn read_to_byte_converter<TOutput: ByteConverter, TStream: AsyncWrite + AsyncRead + Unpin>(stream: &mut TStream) -> Result<TOutput, Box<dyn Error + Send + Sync + 'static>> {
    let usize_length = {
        // byte
        let mut single_byte_chunk = [0u8; 1];
        let read_result = stream.read_exact(&mut single_byte_chunk)
            .await;
        if let Err(error) = read_result {
            let result: Result<TOutput, Box<dyn Error + Send + Sync + 'static>> = Err(Box::new(error));
            return result;
        }

        // length of usize
        single_byte_chunk[0]
    } as usize;

    if !cfg!(target_pointer_width = "64") && usize_length == 8 {
        return Err(TokioByteConError::FailedToExtractSixtyFourBitUsize.into());
    }

    let expected_bytes_length = match usize_length {
        8 => {
            // 8 bytes
            let mut initial_packet = [0u8; 8];
            let read_result = stream.read_exact(&mut initial_packet)
                .await;
            if let Err(error) = read_result {
                let result: Result<TOutput, Box<dyn Error + Send + Sync + 'static>> = Err(Box::new(error));
                return result;
            }

            // u64
            let u64_instance = u64::from_le_bytes(initial_packet);
            usize::try_from(u64_instance)?
        },
        4 => {
            // 4 bytes
            let mut initial_packet = [0u8; 4];
            let read_result = stream.read_exact(&mut initial_packet)
                .await;
            if let Err(error) = read_result {
                let result: Result<TOutput, Box<dyn Error + Send + Sync + 'static>> = Err(Box::new(error));
                return result;
            }

            // u32
            let u32_instance = u32::from_le_bytes(initial_packet);
            usize::try_from(u32_instance)?
        },
        _ => {
            return Err(TokioByteConError::UnexpectedSizeOfUsize {
                bytes_length: usize_length,
            }.into());
        }
    };

    let mut bytes = Vec::new();
    let mut chunk = [0u8; 4096];
    while bytes.len() < expected_bytes_length {
        let read_bytes_length_result = stream.read(&mut chunk)
            .await;
        if let Err(error) = read_bytes_length_result {
            let result: Result<TOutput, Box<dyn Error + Send + Sync + 'static>> = Err(Box::new(error));
            return result;
        }

        let read_bytes_length = read_bytes_length_result.unwrap();

        if read_bytes_length != 0 {
            bytes.extend_from_slice(&chunk[..read_bytes_length]);
        }
    }

    TOutput::deserialize_from_bytes(&bytes)
}

#[inline(always)]
async fn write_from_byte_converter<TStream: AsyncWrite + AsyncRead + Unpin>(stream: &mut TStream, byte_converter: &impl crate::ByteConverter) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
    let byte_converter_bytes = byte_converter.to_vec_bytes()?;
    let byte_converter_bytes_length_bytes = byte_converter_bytes.len().to_vec_bytes()?;
    stream.write(&byte_converter_bytes_length_bytes)
        .await?;
    stream.write(&byte_converter_bytes)
        .await?;
    Ok(())
}

impl ByteStreamReaderAsync for TcpStream {
    #[inline(always)]
    async fn read_to_byte_converter<T: ByteConverter>(&mut self) -> Result<T, Box<dyn Error + Send + Sync + 'static>> {
        read_to_byte_converter(self).await
    }
}

impl ByteStreamWriterAsync for TcpStream {
    #[inline(always)]
    async fn write_from_byte_converter(&mut self, byte_converter: &impl ByteConverter) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
        write_from_byte_converter(self, byte_converter).await
    }
}

impl<TStream: AsyncWrite + AsyncRead + Unpin> ByteStreamReaderAsync for TlsStream<TStream> {
    #[inline(always)]
    async fn read_to_byte_converter<T: ByteConverter>(&mut self) -> Result<T, Box<dyn Error + Send + Sync + 'static>> {
        read_to_byte_converter(self).await
    }
}

impl<TStream: AsyncWrite + AsyncRead + Unpin> ByteStreamWriterAsync for TlsStream<TStream> {
    #[inline(always)]
    async fn write_from_byte_converter(&mut self, byte_converter: &impl crate::ByteConverter) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
        write_from_byte_converter(self, byte_converter).await
    }
}

impl ByteStreamReaderAsync for tokio::sync::mpsc::Receiver<Vec<u8>> {
    #[inline(always)]
    async fn read_to_byte_converter<T: ByteConverter>(&mut self) -> Result<T, Box<dyn Error + Send + Sync + 'static>> {
        let bytes = self.recv()
            .await
            .ok_or(TokioByteConError::OptionVariantNoneReceivedFromReceiver)?;
        T::deserialize_from_bytes(&bytes)
    }
}

impl ByteStreamWriterAsync for tokio::sync::mpsc::Sender<Vec<u8>> {
    #[inline(always)]
    async fn write_from_byte_converter(&mut self, byte_converter: &impl ByteConverter) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
        let bytes = byte_converter.to_vec_bytes()?;
        self.send(bytes)
            .await?;
        Ok(())
    }
}

#[derive(thiserror::Error, Debug)]
enum TokioByteConError {
    #[error("Option variant None received from receiver.")]
    OptionVariantNoneReceivedFromReceiver,
    #[error("Failed to extract 64-bit usize on this machine.")]
    FailedToExtractSixtyFourBitUsize,
    #[error("Unexpected number of bytes {bytes_length} for usize that expects either 4 or 8.")]
    UnexpectedSizeOfUsize {
        bytes_length: usize,
    },
}