Merge pull request #33 from 3Hren/pr/extend-en-de

Extend Encoder/Decoder interface

Author: 3Hren

CHANGELOG.md

@@ -7,6 +7,8 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 - Initial support for [Serde](https://github.com/serde-rs/serde) serializer and deserializer.
 - Efficient bytes serialization with Serde.
 - Efficient binaries deserialization with Serde using `ByteBuf`.
+- Rust serialize Decoder now can provide the underlying reader both by reference or by value, destroying itself in the
+  last case.
 
 ### Changed
 - Renamed `PositiveFixnum` marker to `FixPos`.

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
@@ -2200,11 +2213,26 @@ impl<R: Read> Deserializer<R> {
         }
     }
 
+    /// 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
+    }
+
     fn read_str<V>(&mut self, len: u32, mut visitor: V) -> Result<V::Value>
         where V: serde::de::Visitor
     {
         self.buf.clear();
-        self.buf.extend((0 .. len).map(|_| 0));
+        self.buf.extend((0..len).map(|_| 0));
         visitor.visit_str(try!(read_str_data(&mut self.rd, len, &mut self.buf[..])))
     }
 
@@ -2242,8 +2270,6 @@ impl<R: Read> Deserializer<R> {
 
         visitor.visit_bytes(&mut self.buf[..])
     }
-
-    // TODO: Add an ability to borrow underlying reader and to destruct this decoder.
 }
 
 /// 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> {
@@ -1285,8 +1283,6 @@ impl<'a> Serializer<'a> {
             wr: wr,
         }
     }
-
-    // TODO: An ability to borrow the `Write`.
 }
 
 impl<'a> serde::Serializer for Serializer<'a> {

tests/func/mod.rs

@@ -1,2 +1,4 @@
 mod encode;
 mod decode;
+mod rserialize;
+mod serde;

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());
+}

tests/func/serde.rs

@@ -0,0 +1,42 @@
+use std::io::Cursor;
+
+use serde::Deserialize;
+
+use msgpack::Deserializer;
+
+#[test]
+fn pass_deserializer_get_ref() {
+    let buf = [0xc0];
+    let cur = Cursor::new(&buf[..]);
+
+    let mut de = Deserializer::new(cur);
+
+    assert_eq!((), Deserialize::deserialize(&mut de).ok().unwrap());
+    assert_eq!(1, de.get_ref().position());
+}
+
+#[test]
+fn pass_deserializer_get_mut() {
+    let buf = [0xc0];
+    let cur = Cursor::new(&buf[..]);
+
+    let mut de = Deserializer::new(cur);
+
+    assert_eq!((), Deserialize::deserialize(&mut de).ok().unwrap());
+    de.get_mut().set_position(0);
+
+    assert_eq!((), Deserialize::deserialize(&mut de).ok().unwrap());
+}
+
+#[test]
+fn pass_deserializer_into_inner() {
+    let buf = [0xc0];
+    let cur = Cursor::new(&buf[..]);
+
+    let mut de = Deserializer::new(cur);
+
+    assert_eq!((), Deserialize::deserialize(&mut de).ok().unwrap());
+    let cur = de.into_inner();
+
+    assert_eq!(1, cur.position());
+}