Remove unnecessary API from StreamAdaptor

A StreamAdaptor is only constructed internally in
RustConnection::connect() and cannot be queried by the user. Thus, we
don't need much public API for it.

This commit removes everything that we do not use internally.

If people want to call RustConnection::connect_to_stream() with a
StreamAdaptor, that is still possible, because I left new() public.

Signed-off-by: Uli Schlachter <[email protected]>

x11rb-async/src/rust_connection/stream.rs

@@ -6,10 +6,10 @@ use std::pin::Pin;
 use std::task::{Context, Poll};
 
 #[cfg(unix)]
-use std::os::unix::io::{AsFd, AsRawFd as AsRaw, RawFd};
+use std::os::unix::io::AsFd;
 
 #[cfg(windows)]
-use std::os::windows::io::{AsRawSocket as AsRaw, AsSocket as AsFd, RawSocket};
+use std::os::windows::io::AsRawSocket as AsRaw;
 
 use async_io::Async;
 use futures_lite::future;
@@ -53,40 +53,6 @@ impl<S: AsFd> StreamAdaptor<S> {
     }
 }
 
-impl<S> StreamAdaptor<S> {
-    /// Get a reference to the inner stream.
-    pub fn get_ref(&self) -> &S {
-        self.inner.get_ref()
-    }
-
-    /// Get a mutable reference to the inner stream.
-    ///
-    /// # Safety
-    ///
-    /// This function inherits its unsafety from [`async_io::Async::get_mut`]. This means that the
-    /// underlying I/O source must not be dropped using this function.
-    pub unsafe fn get_mut(&mut self) -> &mut S {
-        self.inner.get_mut()
-    }
-
-    /// Consume this adaptor and return the inner stream.
-    pub fn into_inner(self) -> io::Result<S> {
-        self.inner.into_inner()
-    }
-}
-
-impl<S: AsRaw> AsRaw for StreamAdaptor<S> {
-    #[cfg(unix)]
-    fn as_raw_fd(&self) -> RawFd {
-        self.inner.get_ref().as_raw_fd()
-    }
-
-    #[cfg(windows)]
-    fn as_raw_socket(&self) -> RawSocket {
-        self.inner.get_ref().as_raw_socket()
-    }
-}
-
 /// A future for reading from a [`StreamAdaptor`].
 #[derive(Debug)]
 pub struct Readable<'a, S>(async_io::Readable<'a, S>);
@@ -143,18 +109,18 @@ impl<S: X11rbStream> X11rbStream for StreamAdaptor<S> {
     }
 
     fn read(&self, buf: &mut [u8], fd_storage: &mut Vec<RawFdContainer>) -> io::Result<usize> {
-        self.get_ref().read(buf, fd_storage)
+        self.inner.get_ref().read(buf, fd_storage)
     }
 
     fn write(&self, buf: &[u8], fds: &mut Vec<RawFdContainer>) -> io::Result<usize> {
-        self.get_ref().write(buf, fds)
+        self.inner.get_ref().write(buf, fds)
     }
 
     fn write_vectored(
         &self,
         bufs: &[io::IoSlice<'_>],
         fds: &mut Vec<RawFdContainer>,
     ) -> io::Result<usize> {
-        self.get_ref().write_vectored(bufs, fds)
+        self.inner.get_ref().write_vectored(bufs, fds)
     }
 }