xitca-io 0.6.0

async network io types and traits
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

use core::net::SocketAddr;

use std::io;

use super::Stream;

pub use tokio::net::TcpListener;

// TODO: possible remove the attribute when wasm support tcp socket.
#[cfg(not(target_family = "wasm"))]
pub use tokio::net::TcpSocket;

pub struct TcpStream(pub(crate) tokio::net::TcpStream);

impl TcpStream {
    // TODO: possible remove the attribute when wasm support tcp connect.
    #[cfg(not(target_family = "wasm"))]
    pub async fn connect<A: tokio::net::ToSocketAddrs>(addr: A) -> io::Result<Self> {
        tokio::net::TcpStream::connect(addr).await.map(Self)
    }

    pub fn from_std(stream: std::net::TcpStream) -> io::Result<Self> {
        tokio::net::TcpStream::from_std(stream).map(Self)
    }

    pub fn into_std(self) -> io::Result<std::net::TcpStream> {
        self.0.into_std()
    }

    pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> {
        self.0.set_nodelay(nodelay)
    }
}

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

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

    fn try_from(stream: Stream) -> Result<Self, Self::Error> {
        <(TcpStream, SocketAddr)>::try_from(stream).map(|(tcp, _)| tcp)
    }
}

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

    fn try_from(stream: Stream) -> Result<Self, Self::Error> {
        match stream {
            Stream::Tcp(tcp, addr) => TcpStream::from_std(tcp).map(|tcp| (tcp, addr)),
            #[allow(unreachable_patterns)]
            _ => unreachable!("Can not be casted to TcpStream"),
        }
    }
}

super::default_aio_impl!(TcpStream);

#[cfg(unix)]
mod unix_impl {
    use std::os::unix::io::{AsFd, BorrowedFd};

    use super::TcpStream;

    impl AsFd for TcpStream {
        fn as_fd(&self) -> BorrowedFd<'_> {
            self.0.as_fd()
        }
    }
}

#[cfg(windows)]
mod windows_impl {
    use std::os::windows::io::{AsSocket, BorrowedSocket};

    use super::TcpStream;

    impl AsSocket for TcpStream {
        fn as_socket(&self) -> BorrowedSocket<'_> {
            self.0.as_socket()
        }
    }
}