RUST-429 Move encode_document/decode_document to Document namespace (#175)

Author: isabelatkinson

examples/decode.rs

@@ -1,9 +1,11 @@
 use std::fs::File;
 
+use bson::Document;
+
 fn main() {
     let mut f = File::open("examples/test.bson").unwrap();
 
-    while let Ok(decoded) = bson::decode_document(&mut f) {
+    while let Ok(decoded) = Document::decode(&mut f) {
         println!("{:?}", decoded);
     }
 }

examples/encode.rs

@@ -1,6 +1,6 @@
 use std::io::Cursor;
 
-use bson::{decode_document, encode_document, oid, Array, Bson, Document};
+use bson::{oid, Array, Bson, Document};
 
 fn main() {
     let mut doc = Document::new();
@@ -16,10 +16,10 @@ fn main() {
     doc.insert("array".to_string(), Bson::Array(arr));
 
     let mut buf = Vec::new();
-    encode_document(&mut buf, &doc).unwrap();
+    doc.encode(&mut buf).unwrap();
 
     println!("Encoded: {:?}", buf);
 
-    let doc = decode_document(&mut Cursor::new(&buf[..])).unwrap();
+    let doc = Document::decode(&mut Cursor::new(&buf[..])).unwrap();
     println!("Decoded: {:?}", doc);
 }

fuzz/fuzz_targets/decode.rs

@@ -2,9 +2,9 @@
 #[macro_use] extern crate libfuzzer_sys;
 extern crate bson;
 
-use bson::decode_document;
+use bson::Document;
 use std::io::Cursor;
 
 fuzz_target!(|buf: &[u8]| {
-    let _ = decode_document(&mut Cursor::new(&buf[..]));
+    let _ = Document::decode(&mut Cursor::new(&buf[..]));
 });

src/decoder/mod.rs

@@ -89,7 +89,7 @@ fn read_cstring<R: Read + ?Sized>(reader: &mut R) -> DecoderResult<String> {
 }
 
 #[inline]
-fn read_i32<R: Read + ?Sized>(reader: &mut R) -> DecoderResult<i32> {
+pub(crate) fn read_i32<R: Read + ?Sized>(reader: &mut R) -> DecoderResult<i32> {
     reader.read_i32::<LittleEndian>().map_err(From::from)
 }
 
@@ -109,27 +109,6 @@ fn read_f128<R: Read + ?Sized>(reader: &mut R) -> DecoderResult<Decimal128> {
     Ok(val)
 }
 
-/// Attempt to decode a `Document` from a byte stream.
-pub fn decode_document<R: Read + ?Sized>(reader: &mut R) -> DecoderResult<Document> {
-    let mut doc = Document::new();
-
-    // disregard the length: using Read::take causes infinite type recursion
-    read_i32(reader)?;
-
-    loop {
-        let tag = reader.read_u8()?;
-
-        if tag == 0 {
-            break;
-        }
-
-        let (key, val) = decode_bson_kvp(reader, tag, false)?;
-        doc.insert(key, val);
-    }
-
-    Ok(doc)
-}
-
 fn decode_array<R: Read + ?Sized>(reader: &mut R, utf8_lossy: bool) -> DecoderResult<Array> {
     let mut arr = Array::new();
 
@@ -149,7 +128,7 @@ fn decode_array<R: Read + ?Sized>(reader: &mut R, utf8_lossy: bool) -> DecoderRe
     Ok(arr)
 }
 
-fn decode_bson_kvp<R: Read + ?Sized>(
+pub(crate) fn decode_bson_kvp<R: Read + ?Sized>(
     reader: &mut R,
     tag: u8,
     utf8_lossy: bool,
@@ -160,7 +139,7 @@ fn decode_bson_kvp<R: Read + ?Sized>(
     let val = match ElementType::from(tag) {
         Some(ElementType::FloatingPoint) => Bson::FloatingPoint(reader.read_f64::<LittleEndian>()?),
         Some(ElementType::Utf8String) => read_string(reader, utf8_lossy).map(Bson::String)?,
-        Some(ElementType::EmbeddedDocument) => decode_document(reader).map(Bson::Document)?,
+        Some(ElementType::EmbeddedDocument) => Document::decode(reader).map(Bson::Document)?,
         Some(ElementType::Array) => decode_array(reader, utf8_lossy).map(Bson::Array)?,
         Some(ElementType::Binary) => {
             let mut len = read_i32(reader)?;
@@ -212,7 +191,7 @@ fn decode_bson_kvp<R: Read + ?Sized>(
             read_i32(reader)?;
 
             let code = read_string(reader, utf8_lossy)?;
-            let scope = decode_document(reader)?;
+            let scope = Document::decode(reader)?;
             Bson::JavaScriptCodeWithScope(JavaScriptCodeWithScope { code, scope })
         }
         Some(ElementType::Integer32Bit) => read_i32(reader).map(Bson::I32)?,

src/document.rs

@@ -3,10 +3,14 @@
 use std::{
     error,
     fmt::{self, Debug, Display, Formatter},
-    iter::{Extend, FromIterator, Map},
+    io::{Read, Write},
+    iter::{Extend, FromIterator, IntoIterator, Map},
     marker::PhantomData,
+    mem,
 };
 
+use byteorder::{ReadBytesExt, WriteBytesExt};
+
 use chrono::{DateTime, Utc};
 
 use linked_hash_map::{self, LinkedHashMap};
@@ -17,6 +21,8 @@ use serde::de::{self, MapAccess, Visitor};
 use crate::decimal128::Decimal128;
 use crate::{
     bson::{Array, Binary, Bson, TimeStamp},
+    decoder::{decode_bson_kvp, read_i32, DecoderResult},
+    encoder::{encode_bson, write_i32, EncoderResult},
     oid::ObjectId,
     spec::BinarySubtype,
 };
@@ -503,6 +509,43 @@ impl Document {
             inner: self.inner.entry(k),
         }
     }
+
+    /// Attempts to encode the `Document` into a byte stream.
+    pub fn encode<W: Write + ?Sized>(&self, writer: &mut W) -> EncoderResult<()> {
+        let mut buf = Vec::new();
+        for (key, val) in self.into_iter() {
+            encode_bson(&mut buf, key.as_ref(), val)?;
+        }
+
+        write_i32(
+            writer,
+            (buf.len() + mem::size_of::<i32>() + mem::size_of::<u8>()) as i32,
+        )?;
+        writer.write_all(&buf)?;
+        writer.write_u8(0)?;
+        Ok(())
+    }
+
+    /// Attempts to decode a `Document` from a byte stream.
+    pub fn decode<R: Read + ?Sized>(reader: &mut R) -> DecoderResult<Document> {
+        let mut doc = Document::new();
+
+        // disregard the length: using Read::take causes infinite type recursion
+        read_i32(reader)?;
+
+        loop {
+            let tag = reader.read_u8()?;
+
+            if tag == 0 {
+                break;
+            }
+
+            let (key, val) = decode_bson_kvp(reader, tag, false)?;
+            doc.insert(key, val);
+        }
+
+        Ok(doc)
+    }
 }
 
 pub struct Entry<'a> {

src/encoder/mod.rs

@@ -29,7 +29,7 @@ pub use self::{
     serde::Encoder,
 };
 
-use std::{io::Write, iter::IntoIterator, mem};
+use std::{io::Write, mem};
 
 use byteorder::{LittleEndian, WriteBytesExt};
 use chrono::Timelike;
@@ -56,7 +56,7 @@ fn write_cstring<W: Write + ?Sized>(writer: &mut W, s: &str) -> EncoderResult<()
 }
 
 #[inline]
-fn write_i32<W: Write + ?Sized>(writer: &mut W, val: i32) -> EncoderResult<()> {
+pub(crate) fn write_i32<W: Write + ?Sized>(writer: &mut W, val: i32) -> EncoderResult<()> {
     writer.write_i32::<LittleEndian>(val).map_err(From::from)
 }
 
@@ -92,42 +92,19 @@ fn encode_array<W: Write + ?Sized>(writer: &mut W, arr: &[Bson]) -> EncoderResul
     Ok(())
 }
 
-/// Attempt to encode a `Document` into a byte stream.
-///
-/// Can encode any type which is iterable as `(key: &str, value: &Bson)` pairs,
-/// which generally means most maps.
-pub fn encode_document<
-    'a,
-    S: AsRef<str> + 'a,
-    W: Write + ?Sized,
-    D: IntoIterator<Item = (&'a S, &'a Bson)>,
->(
+pub(crate) fn encode_bson<W: Write + ?Sized>(
     writer: &mut W,
-    doc: D,
+    key: &str,
+    val: &Bson,
 ) -> EncoderResult<()> {
-    let mut buf = Vec::new();
-    for (key, val) in doc.into_iter() {
-        encode_bson(&mut buf, key.as_ref(), val)?;
-    }
-
-    write_i32(
-        writer,
-        (buf.len() + mem::size_of::<i32>() + mem::size_of::<u8>()) as i32,
-    )?;
-    writer.write_all(&buf)?;
-    writer.write_u8(0)?;
-    Ok(())
-}
-
-fn encode_bson<W: Write + ?Sized>(writer: &mut W, key: &str, val: &Bson) -> EncoderResult<()> {
     writer.write_u8(val.element_type() as u8)?;
     write_cstring(writer, key)?;
 
     match *val {
         Bson::FloatingPoint(v) => write_f64(writer, v),
         Bson::String(ref v) => write_string(writer, &v),
         Bson::Array(ref v) => encode_array(writer, &v),
-        Bson::Document(ref v) => encode_document(writer, v),
+        Bson::Document(ref v) => v.encode(writer),
         Bson::Boolean(v) => writer
             .write_u8(if v { 0x01 } else { 0x00 })
             .map_err(From::from),
@@ -146,7 +123,7 @@ fn encode_bson<W: Write + ?Sized>(writer: &mut W, key: &str, val: &Bson) -> Enco
         }) => {
             let mut buf = Vec::new();
             write_string(&mut buf, code)?;
-            encode_document(&mut buf, scope)?;
+            scope.encode(&mut buf)?;
 
             write_i32(writer, buf.len() as i32 + 4)?;
             writer.write_all(&buf).map_err(From::from)

src/lib.rs

@@ -27,16 +27,16 @@
 //! ## Basic usage
 //!
 //! ```rust
-//! use bson::{decode_document, encode_document, Bson, Document};
+//! use bson::{Bson, Document};
 //! use std::io::Cursor;
 //!
 //! let mut doc = Document::new();
 //! doc.insert("foo".to_owned(), Bson::String("bar".to_owned()));
 //!
 //! let mut buf = Vec::new();
-//! encode_document(&mut buf, &doc).unwrap();
+//! doc.encode(&mut buf).unwrap();
 //!
-//! let doc = decode_document(&mut Cursor::new(&buf[..])).unwrap();
+//! let doc = Document::decode(&mut Cursor::new(&buf[..])).unwrap();
 //! ```
 
 #![allow(clippy::cognitive_complexity)]
@@ -55,9 +55,9 @@ pub use self::{
         TimeStamp,
         UtcDateTime,
     },
-    decoder::{decode_document, from_bson, Decoder, DecoderError, DecoderResult},
+    decoder::{from_bson, Decoder, DecoderError, DecoderResult},
     document::{ValueAccessError, ValueAccessResult},
-    encoder::{encode_document, to_bson, Encoder, EncoderError, EncoderResult},
+    encoder::{to_bson, Encoder, EncoderError, EncoderResult},
 };
 
 #[macro_use]