RUST-284: Incorporate rawbson code from rawbson = "0.2.1" in mod raw

Cargo.toml

@@ -55,8 +55,10 @@ serde_bytes = "0.11.5"
 
 [dev-dependencies]
 assert_matches = "1.2"
-serde_bytes = "0.11"
+criterion = "0.3.0"
 pretty_assertions = "0.6.1"
+proptest = "1.0.0"
+serde_bytes = "0.11"
 chrono = { version = "0.4", features = ["serde"] }
 
 [package.metadata.docs.rs]

src/bson.rs

@@ -730,13 +730,10 @@ impl Bson {
                 if let Ok(regex) = doc.get_document("$regularExpression") {
                     if let Ok(pattern) = regex.get_str("pattern") {
                         if let Ok(options) = regex.get_str("options") {
-                            let mut options: Vec<_> = options.chars().collect();
-                            options.sort_unstable();
-
-                            return Bson::RegularExpression(Regex {
-                                pattern: pattern.into(),
-                                options: options.into_iter().collect(),
-                            });
+                            return Bson::RegularExpression(Regex::new(
+                                pattern.into(),
+                                options.into(),
+                            ));
                         }
                     }
                 }
@@ -1014,6 +1011,15 @@ pub struct Regex {
     pub options: String,
 }
 
+impl Regex {
+    pub(crate) fn new(pattern: String, options: String) -> Self {
+        let mut chars: Vec<_> = options.chars().collect();
+        chars.sort_unstable();
+        let options: String = chars.into_iter().collect();
+        Self { pattern, options }
+    }
+}
+
 impl Display for Regex {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         write!(fmt, "/{}/{}", self.pattern, self.options)

src/de/mod.rs

@@ -108,7 +108,7 @@ pub(crate) fn read_string<R: Read + ?Sized>(reader: &mut R, utf8_lossy: bool) ->
     Ok(s)
 }
 
-fn read_bool<R: Read>(mut reader: R) -> Result<bool> {
+pub(crate) fn read_bool<R: Read>(mut reader: R) -> Result<bool> {
     let val = read_u8(&mut reader)?;
     if val > 1 {
         return Err(Error::invalid_value(

src/de/raw.rs

@@ -625,7 +625,7 @@ impl<'de> serde::de::MapAccess<'de> for Decimal128Access {
     where
         V: serde::de::DeserializeSeed<'de>,
     {
-        seed.deserialize(Decimal128Deserializer(self.decimal.clone()))
+        seed.deserialize(Decimal128Deserializer(self.decimal))
     }
 }
 

src/decimal128.rs

@@ -6,7 +6,7 @@ use std::fmt;
 ///
 /// Currently, this type can only be used to round-trip through BSON. See
 /// [RUST-36](https://jira.mongodb.org/browse/RUST-36) to track the progress towards a complete implementation.
-#[derive(Clone, PartialEq)]
+#[derive(Copy, Clone, PartialEq)]
 pub struct Decimal128 {
     /// BSON bytes containing the decimal128. Stored for round tripping.
     pub(crate) bytes: [u8; 128 / 8],

src/extjson/models.rs

@@ -116,14 +116,7 @@ pub(crate) struct RegexBody {
 
 impl Regex {
     pub(crate) fn parse(self) -> crate::Regex {
-        let mut chars: Vec<_> = self.body.options.chars().collect();
-        chars.sort_unstable();
-        let options: String = chars.into_iter().collect();
-
-        crate::Regex {
-            pattern: self.body.pattern,
-            options,
-        }
+        crate::Regex::new(self.body.pattern, self.body.options)
     }
 }
 

src/lib.rs

@@ -280,6 +280,7 @@ pub use self::{
         Deserializer,
     },
     decimal128::Decimal128,
+    raw::{RawDocument, RawDocumentBuf, RawArray},
     ser::{to_bson, to_document, to_vec, Serializer},
     uuid::{Uuid, UuidRepresentation},
 };
@@ -293,6 +294,7 @@ pub mod decimal128;
 pub mod document;
 pub mod extjson;
 pub mod oid;
+pub mod raw;
 pub mod ser;
 pub mod serde_helpers;
 pub mod spec;

src/raw/array.rs

@@ -0,0 +1,242 @@
+use std::convert::TryFrom;
+
+use super::{
+    error::{ValueAccessError, ValueAccessErrorKind, ValueAccessResult},
+    Error,
+    Iter,
+    RawBinary,
+    RawBson,
+    RawDocument,
+    RawRegex,
+    Result,
+};
+use crate::{oid::ObjectId, spec::ElementType, Bson, DateTime, Timestamp};
+
+/// A slice of a BSON document containing a BSON array value (akin to [`std::str`]). This can be
+/// retrieved from a [`RawDocument`] via [`RawDocument::get`].
+///
+/// This is an _unsized_ type, meaning that it must always be used behind a pointer like `&`.
+///
+/// Accessing elements within a [`RawArray`] is similar to element access in [`crate::Document`],
+/// but because the contents are parsed during iteration instead of at creation time, format errors
+/// can happen at any time during use.
+///
+/// Iterating over a [`RawArray`] yields either an error or a value that borrows from the
+/// original document without making any additional allocations.
+///
+/// ```
+/// use bson::{doc, raw::RawDocument};
+///
+/// let doc = doc! {
+///     "x": [1, true, "two", 5.5]
+/// };
+/// let bytes = bson::to_vec(&doc)?;
+///
+/// let rawdoc = RawDocument::new(bytes.as_slice())?;
+/// let rawarray = rawdoc.get_array("x")?;
+///
+/// for v in rawarray {
+///     println!("{:?}", v?);
+/// }
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// Individual elements can be accessed using [`RawArray::get`] or any of
+/// the type-specific getters, such as [`RawArray::get_object_id`] or
+/// [`RawArray::get_str`]. Note that accessing elements is an O(N) operation, as it
+/// requires iterating through the array from the beginning to find the requested index.
+///
+/// ```
+/// # use bson::raw::{ValueAccessError};
+/// use bson::{doc, raw::RawDocument};
+///
+/// let doc = doc! {
+///     "x": [1, true, "two", 5.5]
+/// };
+/// let bytes = bson::to_vec(&doc)?;
+///
+/// let rawdoc = RawDocument::new(bytes.as_slice())?;
+/// let rawarray = rawdoc.get_array("x")?;
+///
+/// assert_eq!(rawarray.get_bool(1)?, true);
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(PartialEq)]
+#[repr(transparent)]
+pub struct RawArray {
+    pub(crate) doc: RawDocument,
+}
+
+impl RawArray {
+    pub(crate) fn from_doc(doc: &RawDocument) -> &RawArray {
+        // SAFETY:
+        //
+        // Dereferencing a raw pointer requires unsafe due to the potential that the pointer is
+        // null, dangling, or misaligned. We know the pointer is not null or dangling due to the
+        // fact that it's created by a safe reference. Converting &RawDocument to *const
+        // RawDocument will be properly aligned due to them being references to the same type,
+        // and converting *const RawDocument to *const RawArray is aligned due to the fact that
+        // the only field in a RawArray is a RawDocument, meaning the structs are represented
+        // identically at the byte level.
+        unsafe { &*(doc as *const RawDocument as *const RawArray) }
+    }
+
+    /// Gets a reference to the value at the given index.
+    pub fn get(&self, index: usize) -> Result<Option<RawBson<'_>>> {
+        self.into_iter().nth(index).transpose()
+    }
+
+    fn get_with<'a, T>(
+        &'a self,
+        index: usize,
+        expected_type: ElementType,
+        f: impl FnOnce(RawBson<'a>) -> Option<T>,
+    ) -> ValueAccessResult<T> {
+        let bson = self
+            .get(index)
+            .map_err(|e| ValueAccessError {
+                key: index.to_string(),
+                kind: ValueAccessErrorKind::InvalidBson(e),
+            })?
+            .ok_or(ValueAccessError {
+                key: index.to_string(),
+                kind: ValueAccessErrorKind::NotPresent,
+            })?;
+        match f(bson) {
+            Some(t) => Ok(t),
+            None => Err(ValueAccessError {
+                key: index.to_string(),
+                kind: ValueAccessErrorKind::UnexpectedType {
+                    expected: expected_type,
+                    actual: bson.element_type(),
+                },
+            }),
+        }
+    }
+
+    /// Gets the BSON double at the given index or returns an error if the value at that index isn't
+    /// a double.
+    pub fn get_f64(&self, index: usize) -> ValueAccessResult<f64> {
+        self.get_with(index, ElementType::Double, RawBson::as_f64)
+    }
+
+    /// Gets a reference to the string at the given index or returns an error if the
+    /// value at that index isn't a string.
+    pub fn get_str(&self, index: usize) -> ValueAccessResult<&str> {
+        self.get_with(index, ElementType::String, RawBson::as_str)
+    }
+
+    /// Gets a reference to the document at the given index or returns an error if the
+    /// value at that index isn't a document.
+    pub fn get_document(&self, index: usize) -> ValueAccessResult<&RawDocument> {
+        self.get_with(index, ElementType::EmbeddedDocument, RawBson::as_document)
+    }
+
+    /// Gets a reference to the array at the given index or returns an error if the
+    /// value at that index isn't a array.
+    pub fn get_array(&self, index: usize) -> ValueAccessResult<&RawArray> {
+        self.get_with(index, ElementType::Array, RawBson::as_array)
+    }
+
+    /// Gets a reference to the BSON binary value at the given index or returns an error if the
+    /// value at that index isn't a binary.
+    pub fn get_binary(&self, index: usize) -> ValueAccessResult<RawBinary<'_>> {
+        self.get_with(index, ElementType::Binary, RawBson::as_binary)
+    }
+
+    /// Gets the ObjectId at the given index or returns an error if the value at that index isn't an
+    /// ObjectId.
+    pub fn get_object_id(&self, index: usize) -> ValueAccessResult<ObjectId> {
+        self.get_with(index, ElementType::ObjectId, RawBson::as_object_id)
+    }
+
+    /// Gets the boolean at the given index or returns an error if the value at that index isn't a
+    /// boolean.
+    pub fn get_bool(&self, index: usize) -> ValueAccessResult<bool> {
+        self.get_with(index, ElementType::Boolean, RawBson::as_bool)
+    }
+
+    /// Gets the DateTime at the given index or returns an error if the value at that index isn't a
+    /// DateTime.
+    pub fn get_datetime(&self, index: usize) -> ValueAccessResult<DateTime> {
+        self.get_with(index, ElementType::DateTime, RawBson::as_datetime)
+    }
+
+    /// Gets a reference to the BSON regex at the given index or returns an error if the
+    /// value at that index isn't a regex.
+    pub fn get_regex(&self, index: usize) -> ValueAccessResult<RawRegex<'_>> {
+        self.get_with(index, ElementType::RegularExpression, RawBson::as_regex)
+    }
+
+    /// Gets a reference to the BSON timestamp at the given index or returns an error if the
+    /// value at that index isn't a timestamp.
+    pub fn get_timestamp(&self, index: usize) -> ValueAccessResult<Timestamp> {
+        self.get_with(index, ElementType::Timestamp, RawBson::as_timestamp)
+    }
+
+    /// Gets the BSON int32 at the given index or returns an error if the value at that index isn't
+    /// a 32-bit integer.
+    pub fn get_i32(&self, index: usize) -> ValueAccessResult<i32> {
+        self.get_with(index, ElementType::Int32, RawBson::as_i32)
+    }
+
+    /// Gets BSON int64 at the given index or returns an error if the value at that index isn't a
+    /// 64-bit integer.
+    pub fn get_i64(&self, index: usize) -> ValueAccessResult<i64> {
+        self.get_with(index, ElementType::Int64, RawBson::as_i64)
+    }
+
+    /// Gets a reference to the raw bytes of the [`RawArray`].
+    pub fn as_bytes(&self) -> &[u8] {
+        self.doc.as_bytes()
+    }
+}
+
+impl std::fmt::Debug for RawArray {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("RawArray")
+            .field("data", &hex::encode(self.doc.as_bytes()))
+            .finish()
+    }
+}
+
+impl TryFrom<&RawArray> for Vec<Bson> {
+    type Error = Error;
+
+    fn try_from(arr: &RawArray) -> Result<Vec<Bson>> {
+        arr.into_iter()
+            .map(|result| {
+                let rawbson = result?;
+                Bson::try_from(rawbson)
+            })
+            .collect()
+    }
+}
+
+impl<'a> IntoIterator for &'a RawArray {
+    type IntoIter = RawArrayIter<'a>;
+    type Item = Result<RawBson<'a>>;
+
+    fn into_iter(self) -> RawArrayIter<'a> {
+        RawArrayIter {
+            inner: self.doc.into_iter(),
+        }
+    }
+}
+
+/// An iterator over borrowed raw BSON array values.
+pub struct RawArrayIter<'a> {
+    inner: Iter<'a>,
+}
+
+impl<'a> Iterator for RawArrayIter<'a> {
+    type Item = Result<RawBson<'a>>;
+
+    fn next(&mut self) -> Option<Result<RawBson<'a>>> {
+        match self.inner.next() {
+            Some(Ok((_, v))) => Some(Ok(v)),
+            Some(Err(e)) => Some(Err(e)),
+            None => None,
+        }
+    }
+}