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

//! Utility for async runtime abstraction

#[cfg(feature = "tokio")]
pub use ntex_tokio::{from_tcp_stream, tcp_connect, tcp_connect_in};

#[cfg(all(unix, feature = "tokio"))]
pub use ntex_tokio::{from_unix_stream, unix_connect, unix_connect_in};

#[cfg(all(
    feature = "async-std",
    not(feature = "tokio"),
    not(feature = "glommio")
))]
pub use ntex_async_std::{from_tcp_stream, tcp_connect, tcp_connect_in};

#[cfg(all(
    unix,
    feature = "async-std",
    not(feature = "tokio"),
    not(feature = "glommio")
))]
pub use ntex_async_std::{from_unix_stream, unix_connect, unix_connect_in};

#[cfg(all(
    feature = "glommio",
    not(feature = "tokio"),
    not(feature = "async-std")
))]
pub use ntex_glommio::{from_tcp_stream, tcp_connect, tcp_connect_in};

#[cfg(all(
    unix,
    feature = "glommio",
    not(feature = "tokio"),
    not(feature = "async-std")
))]
pub use ntex_glommio::{from_unix_stream, unix_connect, unix_connect_in};

#[cfg(all(
    not(feature = "tokio"),
    not(feature = "async-std"),
    not(feature = "glommio")
))]
mod no_rt {
    use ntex_io::Io;

    /// Opens a TCP connection to a remote host.
    pub async fn tcp_connect(_: std::net::SocketAddr) -> std::io::Result<Io> {
        Err(std::io::Error::new(
            std::io::ErrorKind::Other,
            "runtime is not configure",
        ))
    }

    /// Opens a TCP connection to a remote host and use specified memory pool.
    pub async fn tcp_connect_in(
        _: std::net::SocketAddr,
        _: ntex_bytes::PoolRef,
    ) -> std::io::Result<Io> {
        Err(std::io::Error::new(
            std::io::ErrorKind::Other,
            "runtime is not configure",
        ))
    }

    #[cfg(unix)]
    /// Opens a unix stream connection.
    pub async fn unix_connect<'a, P>(_: P) -> std::io::Result<Io>
    where
        P: AsRef<std::path::Path> + 'a,
    {
        Err(std::io::Error::new(
            std::io::ErrorKind::Other,
            "runtime is not configure",
        ))
    }

    #[cfg(unix)]
    /// Opens a unix stream connection and specified memory pool.
    pub async fn unix_connect_in<'a, P>(_: P, _: ntex_bytes::PoolRef) -> std::io::Result<Io>
    where
        P: AsRef<std::path::Path> + 'a,
    {
        Err(std::io::Error::new(
            std::io::ErrorKind::Other,
            "runtime is not configure",
        ))
    }

    /// Convert std TcpStream to tokio's TcpStream
    pub fn from_tcp_stream(_: std::net::TcpStream) -> std::io::Result<Io> {
        Err(std::io::Error::new(
            std::io::ErrorKind::Other,
            "runtime is not configure",
        ))
    }

    #[cfg(unix)]
    /// Convert std UnixStream to tokio's UnixStream
    pub fn from_unix_stream(_: std::os::unix::net::UnixStream) -> std::io::Result<Io> {
        Err(std::io::Error::new(
            std::io::ErrorKind::Other,
            "runtime is not configure",
        ))
    }
}

#[cfg(all(
    not(feature = "tokio"),
    not(feature = "async-std"),
    not(feature = "glommio")
))]
pub use no_rt::*;