Move Connect and FallibleConnect into client module

Author: djc

src/client.rs

@@ -1,3 +1,4 @@
+use std::future::Future;
 #[cfg(unix)]
 use std::os::unix::io::{AsRawFd, RawFd};
 #[cfg(windows)]
@@ -14,10 +15,7 @@ use std::{
 use rustls::{pki_types::ServerName, ClientConfig, ClientConnection};
 use tokio::io::{AsyncBufRead, AsyncRead, AsyncWrite, ReadBuf};
 
-use crate::{
-    common::{IoSession, MidHandshake, Stream, TlsState},
-    Connect,
-};
+use crate::common::{IoSession, MidHandshake, Stream, TlsState};
 
 /// A wrapper around a `rustls::ClientConfig`, providing an async `connect` method.
 #[derive(Clone)]
@@ -151,6 +149,56 @@ impl TlsConnectorWithAlpn<'_> {
     }
 }
 
+/// Future returned from `TlsConnector::connect` which will resolve
+/// once the connection handshake has finished.
+pub struct Connect<IO>(MidHandshake<TlsStream<IO>>);
+
+impl<IO> Connect<IO> {
+    #[inline]
+    pub fn into_fallible(self) -> FallibleConnect<IO> {
+        FallibleConnect(self.0)
+    }
+
+    pub fn get_ref(&self) -> Option<&IO> {
+        match &self.0 {
+            MidHandshake::Handshaking(sess) => Some(sess.get_ref().0),
+            MidHandshake::SendAlert { io, .. } => Some(io),
+            MidHandshake::Error { io, .. } => Some(io),
+            MidHandshake::End => None,
+        }
+    }
+
+    pub fn get_mut(&mut self) -> Option<&mut IO> {
+        match &mut self.0 {
+            MidHandshake::Handshaking(sess) => Some(sess.get_mut().0),
+            MidHandshake::SendAlert { io, .. } => Some(io),
+            MidHandshake::Error { io, .. } => Some(io),
+            MidHandshake::End => None,
+        }
+    }
+}
+
+impl<IO: AsyncRead + AsyncWrite + Unpin> Future for Connect<IO> {
+    type Output = io::Result<TlsStream<IO>>;
+
+    #[inline]
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Pin::new(&mut self.0).poll(cx).map_err(|(err, _)| err)
+    }
+}
+
+impl<IO: AsyncRead + AsyncWrite + Unpin> Future for FallibleConnect<IO> {
+    type Output = Result<TlsStream<IO>, (io::Error, IO)>;
+
+    #[inline]
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Pin::new(&mut self.0).poll(cx)
+    }
+}
+
+/// Like [Connect], but returns `IO` on failure.
+pub struct FallibleConnect<IO>(MidHandshake<TlsStream<IO>>);
+
 /// A wrapper around an underlying raw stream which implements the TLS or SSL
 /// protocol.
 #[derive(Debug)]

src/lib.rs

@@ -64,7 +64,7 @@ macro_rules! ready {
 }
 
 pub mod client;
-pub use client::{TlsConnector, TlsConnectorWithAlpn};
+pub use client::{Connect, FallibleConnect, TlsConnector, TlsConnectorWithAlpn};
 mod common;
 use common::{MidHandshake, TlsState};
 pub mod server;
@@ -295,45 +295,13 @@ where
     }
 }
 
-/// Future returned from `TlsConnector::connect` which will resolve
-/// once the connection handshake has finished.
-pub struct Connect<IO>(MidHandshake<client::TlsStream<IO>>);
-
 /// Future returned from `TlsAcceptor::accept` which will resolve
 /// once the accept handshake has finished.
 pub struct Accept<IO>(MidHandshake<server::TlsStream<IO>>);
 
-/// Like [Connect], but returns `IO` on failure.
-pub struct FallibleConnect<IO>(MidHandshake<client::TlsStream<IO>>);
-
 /// Like [Accept], but returns `IO` on failure.
 pub struct FallibleAccept<IO>(MidHandshake<server::TlsStream<IO>>);
 
-impl<IO> Connect<IO> {
-    #[inline]
-    pub fn into_fallible(self) -> FallibleConnect<IO> {
-        FallibleConnect(self.0)
-    }
-
-    pub fn get_ref(&self) -> Option<&IO> {
-        match &self.0 {
-            MidHandshake::Handshaking(sess) => Some(sess.get_ref().0),
-            MidHandshake::SendAlert { io, .. } => Some(io),
-            MidHandshake::Error { io, .. } => Some(io),
-            MidHandshake::End => None,
-        }
-    }
-
-    pub fn get_mut(&mut self) -> Option<&mut IO> {
-        match &mut self.0 {
-            MidHandshake::Handshaking(sess) => Some(sess.get_mut().0),
-            MidHandshake::SendAlert { io, .. } => Some(io),
-            MidHandshake::Error { io, .. } => Some(io),
-            MidHandshake::End => None,
-        }
-    }
-}
-
 impl<IO> Accept<IO> {
     #[inline]
     pub fn into_fallible(self) -> FallibleAccept<IO> {
@@ -359,15 +327,6 @@ impl<IO> Accept<IO> {
     }
 }
 
-impl<IO: AsyncRead + AsyncWrite + Unpin> Future for Connect<IO> {
-    type Output = io::Result<client::TlsStream<IO>>;
-
-    #[inline]
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        Pin::new(&mut self.0).poll(cx).map_err(|(err, _)| err)
-    }
-}
-
 impl<IO: AsyncRead + AsyncWrite + Unpin> Future for Accept<IO> {
     type Output = io::Result<server::TlsStream<IO>>;
 
@@ -377,15 +336,6 @@ impl<IO: AsyncRead + AsyncWrite + Unpin> Future for Accept<IO> {
     }
 }
 
-impl<IO: AsyncRead + AsyncWrite + Unpin> Future for FallibleConnect<IO> {
-    type Output = Result<client::TlsStream<IO>, (io::Error, IO)>;
-
-    #[inline]
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        Pin::new(&mut self.0).poll(cx)
-    }
-}
-
 impl<IO: AsyncRead + AsyncWrite + Unpin> Future for FallibleAccept<IO> {
     type Output = Result<server::TlsStream<IO>, (io::Error, IO)>;