From afbe6667f98dd9396c102e9c5b033681c2dcf6b2 Mon Sep 17 00:00:00 2001
From: "Neal H. Walfield" <neal@pep.foundation>
Date: Fri, 23 Feb 2018 12:17:24 +0100
Subject: buffered-reader: Add methods to get a reference to the inner reader.

  - To be able to walk a stack of buffered readers without consuming
    them, add the get_mut and get_ref methods to the `BufferedReader`
    trait.
---
 buffered-reader/src/decompress.rs | 30 +++++++++++++++++++++++++++---
 buffered-reader/src/generic.rs    |  8 ++++++++
 buffered-reader/src/lib.rs        | 21 +++++++++++++++++++++
 buffered-reader/src/limitor.rs    |  8 ++++++++
 buffered-reader/src/memory.rs     |  8 ++++++++
 5 files changed, 72 insertions(+), 3 deletions(-)

(limited to 'buffered-reader')

diff --git a/buffered-reader/src/decompress.rs b/buffered-reader/src/decompress.rs
index 0bad2e48..81a11e48 100644
--- a/buffered-reader/src/decompress.rs
+++ b/buffered-reader/src/decompress.rs
@@ -88,10 +88,18 @@ impl<R: BufferedReader<C>, C> BufferedReader<C>
         return self.reader.steal_eof();
     }
 
+    fn get_mut(&mut self) -> Option<&mut BufferedReader<C>> {
+        Some(self.reader.reader.get_mut())
+    }
+
+    fn get_ref(&self) -> Option<&BufferedReader<C>> {
+        Some(self.reader.reader.get_ref())
+    }
+
     fn into_inner<'b>(self: Box<Self>)
             -> Option<Box<BufferedReader<C> + 'b>> where Self: 'b {
         // Strip the outer box.
-        Some(Box::new((*self).reader.reader.into_inner()))
+        Some(Box::new(self.reader.reader.into_inner()))
     }
 
     fn cookie_set(&mut self, cookie: C) -> C {
@@ -188,10 +196,18 @@ impl<R: BufferedReader<C>, C> BufferedReader<C>
         return self.reader.steal_eof();
     }
 
+    fn get_mut(&mut self) -> Option<&mut BufferedReader<C>> {
+        Some(self.reader.reader.get_mut())
+    }
+
+    fn get_ref(&self) -> Option<&BufferedReader<C>> {
+        Some(self.reader.reader.get_ref())
+    }
+
     fn into_inner<'b>(self: Box<Self>)
             -> Option<Box<BufferedReader<C> + 'b>> where Self: 'b {
         // Strip the outer box.
-        Some(Box::new((*self).reader.reader.into_inner()))
+        Some(Box::new(self.reader.reader.into_inner()))
     }
 
     fn cookie_set(&mut self, cookie: C) -> C {
@@ -287,10 +303,18 @@ impl<R: BufferedReader<C>, C> BufferedReader<C> for BufferedReaderBzip<R, C> {
         return self.reader.steal_eof();
     }
 
+    fn get_mut(&mut self) -> Option<&mut BufferedReader<C>> {
+        Some(self.reader.reader.get_mut())
+    }
+
+    fn get_ref(&self) -> Option<&BufferedReader<C>> {
+        Some(self.reader.reader.get_ref())
+    }
+
     fn into_inner<'b>(self: Box<Self>)
             -> Option<Box<BufferedReader<C> + 'b>> where Self: 'b {
         // Strip the outer box.
-        Some(Box::new((*self).reader.reader.into_inner()))
+        Some(Box::new(self.reader.reader.into_inner()))
     }
 
     fn cookie_set(&mut self, cookie: C) -> C {
diff --git a/buffered-reader/src/generic.rs b/buffered-reader/src/generic.rs
index b8a0ad25..81469efd 100644
--- a/buffered-reader/src/generic.rs
+++ b/buffered-reader/src/generic.rs
@@ -232,6 +232,14 @@ impl<T: io::Read, C> BufferedReader<C> for BufferedReaderGeneric<T, C> {
         return self.data_helper(amount, true, true);
     }
 
+    fn get_mut(&mut self) -> Option<&mut BufferedReader<C>> {
+        None
+    }
+
+    fn get_ref(&self) -> Option<&BufferedReader<C>> {
+        None
+    }
+
     fn into_inner<'b>(self: Box<Self>) -> Option<Box<BufferedReader<C> + 'b>>
         where Self: 'b {
         None
diff --git a/buffered-reader/src/lib.rs b/buffered-reader/src/lib.rs
index 4738ed2c..82cab946 100644
--- a/buffered-reader/src/lib.rs
+++ b/buffered-reader/src/lib.rs
@@ -172,6 +172,17 @@ pub trait BufferedReader<C> : io::Read + fmt::Debug {
     fn into_inner<'a>(self: Box<Self>) -> Option<Box<BufferedReader<C> + 'a>>
         where Self: 'a;
 
+    /// Returns a mutable reference to the inner `BufferedReader`, if
+    /// any.
+    ///
+    /// It is a very bad idea to read any data from the inner
+    /// `BufferedReader`, but it can sometimes be useful to get the
+    /// cookie.
+    fn get_mut(&mut self) -> Option<&mut BufferedReader<C>>;
+
+    /// Returns a reference to the inner `BufferedReader`.
+    fn get_ref(&self) -> Option<&BufferedReader<C>>;
+
     /// Sets the `BufferedReader`'s cookie and returns the old value.
     fn cookie_set(&mut self, cookie: C) -> C;
 
@@ -264,6 +275,16 @@ impl <'a, C> BufferedReader<C> for Box<BufferedReader<C> + 'a> {
         return self.as_mut().drop_eof();
     }
 
+    fn get_mut(&mut self) -> Option<&mut BufferedReader<C>> {
+        // Strip the outer box.
+        self.as_mut().get_mut()
+    }
+
+    fn get_ref(&self) -> Option<&BufferedReader<C>> {
+        // Strip the outer box.
+        self.as_ref().get_ref()
+    }
+
     fn into_inner<'b>(self: Box<Self>) -> Option<Box<BufferedReader<C> + 'b>>
             where Self: 'b {
         // Strip the outer box.
diff --git a/buffered-reader/src/limitor.rs b/buffered-reader/src/limitor.rs
index 04916ef6..0bce61f9 100644
--- a/buffered-reader/src/limitor.rs
+++ b/buffered-reader/src/limitor.rs
@@ -99,6 +99,14 @@ impl<T: BufferedReader<C>, C> BufferedReader<C> for BufferedReaderLimitor<T, C>
         return result;
     }
 
+    fn get_mut(&mut self) -> Option<&mut BufferedReader<C>> {
+        Some(&mut self.reader)
+    }
+
+    fn get_ref(&self) -> Option<&BufferedReader<C>> {
+        Some(&self.reader)
+    }
+
     fn into_inner<'b>(self: Box<Self>) -> Option<Box<BufferedReader<C> + 'b>>
             where Self: 'b {
         Some(Box::new(self.reader))
diff --git a/buffered-reader/src/memory.rs b/buffered-reader/src/memory.rs
index 2bdc0eb2..5bbc2e13 100644
--- a/buffered-reader/src/memory.rs
+++ b/buffered-reader/src/memory.rs
@@ -92,6 +92,14 @@ impl<'a, C> BufferedReader<C> for BufferedReaderMemory<'a, C> {
         return Ok(self.consume(amount));
     }
 
+    fn get_mut(&mut self) -> Option<&mut BufferedReader<C>> {
+        None
+    }
+
+    fn get_ref(&self) -> Option<&BufferedReader<C>> {
+        None
+    }
+
     fn into_inner<'b>(self: Box<Self>) -> Option<Box<BufferedReader<C> + 'b>>
             where Self: 'b {
         None
-- 
cgit v1.2.3