Decoder: an ability to borrow the underlying R.

Or to consume the decoder obtaining the underlying reader.

Author: 3Hren

src/decode.rs

@@ -1810,7 +1810,20 @@ impl<R: Read> Decoder<R> {
         }
     }
 
-    // TODO: Add an ability to borrow underlying reader and to destruct this decoder.
+    /// Gets a reference to the underlying reader in this decoder.
+    pub fn get_ref(&self) -> &R {
+        &self.rd
+    }
+
+    /// Gets a mutable reference to the underlying reader in this decoder.
+    pub fn get_mut(&mut self) -> &mut R {
+        &mut self.rd
+    }
+
+    /// Consumes this decoder returning the underlying reader.
+    pub fn into_inner(self) -> R {
+        self.rd
+    }
 }
 
 /// Unstable: docs; examples; incomplete

src/encode.rs

@@ -972,7 +972,7 @@ impl From<ValueWriteError> for Error {
 ///
 /// All instances of `ErrorKind::Interrupted` are handled by this function and the underlying
 /// operation is retried.
-// TODO: Docs. Examples.
+// TODO: Docs. Examples, variant encoding policy.
 pub struct Encoder<'a> {
     wr: &'a mut Write,
 }
@@ -984,8 +984,6 @@ impl<'a> Encoder<'a> {
             wr: wr,
         }
     }
-
-    // TODO: An ability to borrow the `Write`.
 }
 
 impl<'a> serialize::Encoder for Encoder<'a> {

tests/func/mod.rs

@@ -1,2 +1,3 @@
 mod encode;
 mod decode;
+mod rserialize;

tests/func/rserialize.rs

@@ -0,0 +1,42 @@
+use std::io::Cursor;
+
+use rustc_serialize::Decodable;
+
+use msgpack::Decoder;
+
+#[test]
+fn pass_decoder_get_ref() {
+    let buf = [0xc0];
+    let cur = Cursor::new(&buf[..]);
+
+    let mut decoder = Decoder::new(cur);
+
+    assert_eq!((), Decodable::decode(&mut decoder).ok().unwrap());
+    assert_eq!(1, decoder.get_ref().position());
+}
+
+#[test]
+fn pass_decoder_get_mut() {
+    let buf = [0xc0];
+    let cur = Cursor::new(&buf[..]);
+
+    let mut decoder = Decoder::new(cur);
+
+    assert_eq!((), Decodable::decode(&mut decoder).ok().unwrap());
+    decoder.get_mut().set_position(0);
+
+    assert_eq!((), Decodable::decode(&mut decoder).ok().unwrap());
+}
+
+#[test]
+fn pass_decoder_into_inner() {
+    let buf = [0xc0];
+    let cur = Cursor::new(&buf[..]);
+
+    let mut decoder = Decoder::new(cur);
+
+    assert_eq!((), Decodable::decode(&mut decoder).ok().unwrap());
+    let cur = decoder.into_inner();
+
+    assert_eq!(1, cur.position());
+}