provide lazy iterator implementation (#449)

Author: tychoish

src/raw/array.rs

@@ -6,10 +6,10 @@ use super::{
     error::{ValueAccessError, ValueAccessErrorKind, ValueAccessResult},
     serde::OwnedOrBorrowedRawArray,
     Error,
-    Iter,
     RawBinaryRef,
     RawBsonRef,
     RawDocument,
+    RawIter,
     RawRegexRef,
     Result,
 };
@@ -260,22 +260,25 @@ impl<'a> IntoIterator for &'a RawArray {
 
     fn into_iter(self) -> RawArrayIter<'a> {
         RawArrayIter {
-            inner: self.doc.into_iter(),
+            inner: RawIter::new(&self.doc),
         }
     }
 }
 
 /// An iterator over borrowed raw BSON array values.
 pub struct RawArrayIter<'a> {
-    inner: Iter<'a>,
+    inner: RawIter<'a>,
 }
 
 impl<'a> Iterator for RawArrayIter<'a> {
     type Item = Result<RawBsonRef<'a>>;
 
     fn next(&mut self) -> Option<Result<RawBsonRef<'a>>> {
         match self.inner.next() {
-            Some(Ok((_, v))) => Some(Ok(v)),
+            Some(Ok(elem)) => match elem.value() {
+                Ok(value) => Some(Ok(value)),
+                Err(e) => Some(Err(e)),
+            },
             Some(Err(e)) => Some(Err(e)),
             None => None,
         }

src/raw/document.rs

@@ -15,12 +15,14 @@ use crate::{
 use super::{
     error::{ValueAccessError, ValueAccessErrorKind, ValueAccessResult},
     i32_from_slice,
+    iter::Iter,
+    try_to_str,
     Error,
-    Iter,
     RawArray,
     RawBinaryRef,
     RawBsonRef,
     RawDocumentBuf,
+    RawIter,
     RawRegexRef,
     Result,
 };
@@ -170,10 +172,10 @@ impl RawDocument {
     /// # Ok::<(), Error>(())
     /// ```
     pub fn get(&self, key: impl AsRef<str>) -> Result<Option<RawBsonRef<'_>>> {
-        for result in self.into_iter() {
-            let (k, v) = result?;
-            if key.as_ref() == k {
-                return Ok(Some(v));
+        for elem in RawIter::new(self) {
+            let elem = elem?;
+            if key.as_ref() == elem.key() {
+                return Ok(Some(elem.try_into()?));
             }
         }
         Ok(None)
@@ -492,6 +494,22 @@ impl RawDocument {
     pub fn is_empty(&self) -> bool {
         self.as_bytes().len() == MIN_BSON_DOCUMENT_SIZE as usize
     }
+
+    pub(crate) fn read_cstring_at(&self, start_at: usize) -> Result<&str> {
+        let buf = &self.as_bytes()[start_at..];
+
+        let mut splits = buf.splitn(2, |x| *x == 0);
+        let value = splits
+            .next()
+            .ok_or_else(|| Error::new_without_key(ErrorKind::new_malformed("no value")))?;
+        if splits.next().is_some() {
+            Ok(try_to_str(value)?)
+        } else {
+            Err(Error::new_without_key(ErrorKind::new_malformed(
+                "expected null terminator",
+            )))
+        }
+    }
 }
 
 impl<'de: 'a, 'a> Deserialize<'de> for &'a RawDocument {

src/raw/document_buf.rs

@@ -17,12 +17,13 @@ use crate::{
 
 use super::{
     bson::RawBson,
+    iter::Iter,
     serde::OwnedOrBorrowedRawDocument,
     Error,
     ErrorKind,
-    Iter,
     RawBsonRef,
     RawDocument,
+    RawIter,
     Result,
 };
 
@@ -147,7 +148,27 @@ impl RawDocumentBuf {
     /// elements that might need to allocate, you must explicitly convert
     /// them to owned types yourself.
     pub fn iter(&self) -> Iter<'_> {
-        self.into_iter()
+        Iter::new(self)
+    }
+
+    /// Gets an iterator over the elements in the [`RawDocumentBuf`],
+    /// which yields `Result<RawElement<'_>>` values. These hold a
+    /// reference to the underlying document but do not explicitly
+    /// resolve the values.
+    ///
+    /// This iterator, which underpins the implementation of the
+    /// default iterator, produces `RawElement` objects, which
+    /// hold a view onto the document but do not parse out or
+    /// construct values until the `.value()` or `.try_into()` methods
+    /// are called.
+    ///
+    /// # Note:
+    ///
+    /// There is no owning iterator for [`RawDocumentBuf`]. If you
+    /// need ownership over elements that might need to allocate, you
+    /// must explicitly convert them to owned types yourself.
+    pub fn iter_elements(&self) -> RawIter<'_> {
+        RawIter::new(self)
     }
 
     /// Return the contained data as a `Vec<u8>`

src/raw/error.rs

@@ -48,6 +48,14 @@ pub enum ErrorKind {
     Utf8EncodingError(Utf8Error),
 }
 
+impl ErrorKind {
+    pub(crate) fn new_malformed(e: impl ToString) -> Self {
+        ErrorKind::MalformedValue {
+            message: e.to_string(),
+        }
+    }
+}
+
 impl std::fmt::Display for Error {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         let p = self