boomnet 0.0.78

Framework for building low latency clients on top of TCP.
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

//! Wrapper over `std::net::TcpStream`.

use crate::service::select::Selectable;
use crate::stream::{ConnectionInfo, ConnectionInfoProvider};
use std::io;
use std::io::{Read, Write};
use std::net::SocketAddr;
use std::os::fd::{AsRawFd, RawFd};

/// Wraps `std::net::TcpStream` and provides `ConnectionInfo`.
#[derive(Debug)]
pub struct TcpStream {
    inner: std::net::TcpStream,
    connection_info: ConnectionInfo,
}

impl AsRawFd for TcpStream {
    fn as_raw_fd(&self) -> RawFd {
        self.inner.as_raw_fd()
    }
}

impl From<TcpStream> for std::net::TcpStream {
    fn from(stream: TcpStream) -> Self {
        stream.inner
    }
}

impl TryFrom<(&str, u16)> for TcpStream {
    type Error = io::Error;

    fn try_from(host_and_port: (&str, u16)) -> Result<Self, Self::Error> {
        ConnectionInfo::from(host_and_port).try_into()
    }
}

impl TryFrom<ConnectionInfo> for TcpStream {
    type Error = io::Error;

    fn try_from(connection_info: ConnectionInfo) -> Result<Self, Self::Error> {
        connection_info.into_tcp_stream()
    }
}

impl TryFrom<&ConnectionInfo> for TcpStream {
    type Error = io::Error;

    fn try_from(connection_info: &ConnectionInfo) -> Result<Self, Self::Error> {
        connection_info.clone().into_tcp_stream()
    }
}

impl TryFrom<(&ConnectionInfo, SocketAddr)> for TcpStream {
    type Error = io::Error;

    fn try_from(conn_and_addr: (&ConnectionInfo, SocketAddr)) -> Result<Self, Self::Error> {
        let (conn, addr) = conn_and_addr;
        conn.clone().into_tcp_stream_with_addr(addr)
    }
}

impl TryFrom<(ConnectionInfo, SocketAddr)> for TcpStream {
    type Error = io::Error;

    fn try_from(conn_and_addr: (ConnectionInfo, SocketAddr)) -> Result<Self, Self::Error> {
        let (conn, addr) = conn_and_addr;
        conn.into_tcp_stream_with_addr(addr)
    }
}

impl TcpStream {
    pub const fn new(stream: std::net::TcpStream, connection_info: ConnectionInfo) -> Self {
        Self {
            inner: stream,
            connection_info,
        }
    }

    #[inline]
    pub fn connected(&mut self) -> bool {
        self.inner.peer_addr().is_ok()
    }
}

impl Read for TcpStream {
    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
        self.inner.read(buf)
    }
}

impl Write for TcpStream {
    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
        self.inner.write(buf)
    }

    fn flush(&mut self) -> std::io::Result<()> {
        self.inner.flush()
    }
}

impl Selectable for TcpStream {
    fn connected(&mut self) -> io::Result<bool> {
        Ok(true)
    }

    fn make_writable(&mut self) -> io::Result<()> {
        Ok(())
    }

    fn make_readable(&mut self) -> io::Result<()> {
        Ok(())
    }
}

impl ConnectionInfoProvider for TcpStream {
    fn connection_info(&self) -> &ConnectionInfo {
        &self.connection_info
    }
}