Add get_ref/get_mut/get_pin_mut/into_inner methods

Author: taiki-e

futures-util/src/sink/buffer.rs

@@ -36,6 +36,24 @@ impl<Si: Sink<Item>, Item> Buffer<Si, Item> {
         &self.sink
     }
 
+    /// Get a mutable reference to the inner sink.
+    pub fn get_mut(&mut self) -> &mut Si {
+        &mut self.sink
+    }
+
+    /// Get a pinned mutable reference to the inner sink.
+    pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut Si> {
+        unsafe { Pin::map_unchecked_mut(self, Self::get_mut) }
+    }
+
+    /// Consumes this combinator, returning the underlying sink.
+    ///
+    /// Note that this may discard intermediate state of this combinator, so
+    /// care should be taken to avoid losing resources when this is called.
+    pub fn into_inner(self) -> Si {
+        self.sink
+    }
+
     fn try_empty_buffer(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,

futures-util/src/sink/err_into.rs

@@ -34,6 +34,11 @@ impl<Si, E, Item> SinkErrInto<Si, Item, E>
         self.sink.get_mut()
     }
 
+    /// Get a pinned mutable reference to the inner sink.
+    pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut Si> {
+        unsafe { Pin::map_unchecked_mut(self, Self::get_mut) }
+    }
+
     /// Consumes this combinator, returning the underlying sink.
     ///
     /// Note that this may discard intermediate state of this combinator, so

futures-util/src/sink/fanout.rs

@@ -21,6 +21,24 @@ impl<Si1, Si2> Fanout<Si1, Si2> {
         Fanout { sink1, sink2 }
     }
 
+    /// Get a shared reference to the inner sinks.
+    pub fn get_ref(&self) -> (&Si1, &Si2) {
+        (&self.sink1, &self.sink2)
+    }
+
+    /// Get a mutable reference to the inner sinks.
+    pub fn get_mut(&mut self) -> (&mut Si1, &mut Si2) {
+        (&mut self.sink1, &mut self.sink2)
+    }
+
+    /// Get a pinned mutable reference to the inner sinks.
+    pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> (Pin<&'a mut Si1>, Pin<&'a mut Si2>)
+        where Si1: Unpin, Si2: Unpin,
+    {
+        let Self { sink1, sink2 } = Pin::get_mut(self);
+        (Pin::new(sink1), Pin::new(sink2))
+    }
+
     /// Consumes this combinator, returning the underlying sinks.
     ///
     /// Note that this may discard intermediate state of this combinator,

futures-util/src/sink/map_err.rs

@@ -32,9 +32,9 @@ impl<Si, F> SinkMapErr<Si, F> {
         &mut self.sink
     }
 
-    /// Get a pinned reference to the inner sink.
+    /// Get a pinned mutable reference to the inner sink.
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut Si> {
-        unsafe { Pin::map_unchecked_mut(self, |x| &mut x.sink) }
+        unsafe { Pin::map_unchecked_mut(self, Self::get_mut) }
     }
 
     /// Consumes this combinator, returning the underlying sink.

futures-util/src/sink/with.rs

@@ -107,6 +107,11 @@ impl<Si, Item, U, Fut, F, E> With<Si, Item, U, Fut, F>
         &mut self.sink
     }
 
+    /// Get a pinned mutable reference to the inner sink.
+    pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut Si> {
+        unsafe { Pin::map_unchecked_mut(self, Self::get_mut) }
+    }
+
     /// Consumes this combinator, returning the underlying sink.
     ///
     /// Note that this may discard intermediate state of this combinator, so

futures-util/src/sink/with_flat_map.rs

@@ -60,7 +60,7 @@ where
 
     /// Get a pinned mutable reference to the inner sink.
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut Si> {
-        unsafe { Pin::map_unchecked_mut(self, |x| &mut x.sink) }
+        unsafe { Pin::map_unchecked_mut(self, Self::get_mut) }
     }
 
     /// Consumes this combinator, returning the underlying sink.

futures-util/src/stream/buffer_unordered.rs

@@ -81,7 +81,7 @@ where
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        unsafe { Pin::map_unchecked_mut(self, |x| x.get_mut()) }
+        unsafe { Pin::map_unchecked_mut(self, Self::get_mut) }
     }
 
     /// Consumes this combinator, returning the underlying stream.

futures-util/src/stream/buffered.rs

@@ -70,13 +70,13 @@ where
         self.stream.get_mut()
     }
 
-    /// Acquires a mutable pinned reference to the underlying stream that this
+    /// Acquires a pinned mutable reference to the underlying stream that this
     /// combinator is pulling from.
     ///
     /// Note that care must be taken to avoid tampering with the state of the
     /// stream which may otherwise confuse this combinator.
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
-        unsafe { Pin::map_unchecked_mut(self, |x| x.get_mut()) }
+        unsafe { Pin::map_unchecked_mut(self, Self::get_mut) }
     }
 
     /// Consumes this combinator, returning the underlying stream.

futures-util/src/stream/chunks.rs

@@ -52,6 +52,15 @@ impl<St: Stream> Chunks<St> where St: Stream {
         self.stream.get_mut()
     }
 
+    /// Acquires a pinned mutable reference to the underlying stream that this
+    /// combinator is pulling from.
+    ///
+    /// Note that care must be taken to avoid tampering with the state of the
+    /// stream which may otherwise confuse this combinator.
+    pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
+        unsafe { Pin::map_unchecked_mut(self, Self::get_mut) }
+    }
+
     /// Consumes this combinator, returning the underlying stream.
     ///
     /// Note that this may discard intermediate state of this combinator, so

futures-util/src/stream/enumerate.rs

@@ -24,6 +24,38 @@ impl<St: Stream> Enumerate<St> {
             count: 0,
         }
     }
+
+    /// Acquires a reference to the underlying stream that this combinator is
+    /// pulling from.
+    pub fn get_ref(&self) -> &St {
+        &self.stream
+    }
+
+    /// Acquires a mutable reference to the underlying stream that this
+    /// combinator is pulling from.
+    ///
+    /// Note that care must be taken to avoid tampering with the state of the
+    /// stream which may otherwise confuse this combinator.
+    pub fn get_mut(&mut self) -> &mut St {
+        &mut self.stream
+    }
+
+    /// Acquires a pinned mutable reference to the underlying stream that this
+    /// combinator is pulling from.
+    ///
+    /// Note that care must be taken to avoid tampering with the state of the
+    /// stream which may otherwise confuse this combinator.
+    pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
+        unsafe { Pin::map_unchecked_mut(self, Self::get_mut) }
+    }
+
+    /// Consumes this combinator, returning the underlying stream.
+    ///
+    /// Note that this may discard intermediate state of this combinator, so
+    /// care should be taken to avoid losing resources when this is called.
+    pub fn into_inner(self) -> St {
+        self.stream
+    }
 }
 
 impl<St: Stream + FusedStream> FusedStream for Enumerate<St> {