refactor top-level module into submodules

Author: saghm

src/raw/array.rs

@@ -1,10 +1,24 @@
+use std::convert::TryFrom;
+
+use super::{
+    Error,
+    RawBinary,
+    RawBson,
+    RawDocumentIter,
+    RawDocumentRef,
+    RawRegex,
+    RawTimestamp,
+    Result,
+};
+use crate::{oid::ObjectId, Bson, DateTime};
+
 /// A BSON array referencing raw bytes stored elsewhere.
 pub struct RawArray {
     doc: RawDocumentRef,
 }
 
 impl RawArray {
-    fn new(data: &[u8]) -> RawResult<&RawArray> {
+    pub(super) fn new(data: &[u8]) -> Result<&RawArray> {
         Ok(RawArray::from_doc(RawDocumentRef::new(data)?))
     }
 
@@ -22,88 +36,88 @@ impl RawArray {
     }
 
     /// Gets a reference to the value at the given index.
-    pub fn get(&self, index: usize) -> RawResult<Option<RawBson<'_>>> {
+    pub fn get(&self, index: usize) -> Result<Option<RawBson<'_>>> {
         self.into_iter().nth(index).transpose()
     }
 
     fn get_with<'a, T>(
         &'a self,
         index: usize,
-        f: impl FnOnce(elem::RawBson<'a>) -> RawResult<T>,
-    ) -> RawResult<Option<T>> {
+        f: impl FnOnce(RawBson<'a>) -> Result<T>,
+    ) -> Result<Option<T>> {
         self.get(index)?.map(f).transpose()
     }
 
     /// 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) -> RawResult<Option<f64>> {
-        self.get_with(index, elem::RawBson::as_f64)
+    pub fn get_f64(&self, index: usize) -> Result<Option<f64>> {
+        self.get_with(index, 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) -> RawResult<Option<&str>> {
-        self.get_with(index, elem::RawBson::as_str)
+    pub fn get_str(&self, index: usize) -> Result<Option<&str>> {
+        self.get_with(index, 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) -> RawResult<Option<&RawDocumentRef>> {
-        self.get_with(index, elem::RawBson::as_document)
+    pub fn get_document(&self, index: usize) -> Result<Option<&RawDocumentRef>> {
+        self.get_with(index, 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) -> RawResult<Option<&RawArray>> {
-        self.get_with(index, elem::RawBson::as_array)
+    pub fn get_array(&self, index: usize) -> Result<Option<&RawArray>> {
+        self.get_with(index, 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) -> RawResult<Option<RawBinary<'_>>> {
-        self.get_with(index, elem::RawBson::as_binary)
+    pub fn get_binary(&self, index: usize) -> Result<Option<RawBinary<'_>>> {
+        self.get_with(index, 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) -> RawResult<Option<ObjectId>> {
-        self.get_with(index, elem::RawBson::as_object_id)
+    pub fn get_object_id(&self, index: usize) -> Result<Option<ObjectId>> {
+        self.get_with(index, 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) -> RawResult<Option<bool>> {
-        self.get_with(index, elem::RawBson::as_bool)
+    pub fn get_bool(&self, index: usize) -> Result<Option<bool>> {
+        self.get_with(index, 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) -> RawResult<Option<DateTime<Utc>>> {
-        self.get_with(index, elem::RawBson::as_datetime)
+    pub fn get_datetime(&self, index: usize) -> Result<Option<DateTime>> {
+        Ok(self.get_with(index, RawBson::as_datetime)?.map(Into::into))
     }
 
     /// 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) -> RawResult<Option<RawRegex<'_>>> {
-        self.get_with(index, elem::RawBson::as_regex)
+    pub fn get_regex(&self, index: usize) -> Result<Option<RawRegex<'_>>> {
+        self.get_with(index, 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) -> RawResult<Option<RawTimestamp<'_>>> {
-        self.get_with(index, elem::RawBson::as_timestamp)
+    pub fn get_timestamp(&self, index: usize) -> Result<Option<RawTimestamp<'_>>> {
+        self.get_with(index, 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) -> RawResult<Option<i32>> {
-        self.get_with(index, elem::RawBson::as_i32)
+    pub fn get_i32(&self, index: usize) -> Result<Option<i32>> {
+        self.get_with(index, 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) -> RawResult<Option<i64>> {
-        self.get_with(index, elem::RawBson::as_i64)
+    pub fn get_i64(&self, index: usize) -> Result<Option<i64>> {
+        self.get_with(index, RawBson::as_i64)
     }
 
     /// Gets a reference to the raw bytes of the RawArray.
@@ -115,7 +129,7 @@ impl RawArray {
 impl TryFrom<&RawArray> for Vec<Bson> {
     type Error = Error;
 
-    fn try_from(arr: &RawArray) -> RawResult<Vec<Bson>> {
+    fn try_from(arr: &RawArray) -> Result<Vec<Bson>> {
         arr.into_iter()
             .map(|result| {
                 let rawbson = result?;
@@ -127,7 +141,7 @@ impl TryFrom<&RawArray> for Vec<Bson> {
 
 impl<'a> IntoIterator for &'a RawArray {
     type IntoIter = RawArrayIter<'a>;
-    type Item = RawResult<elem::RawBson<'a>>;
+    type Item = Result<RawBson<'a>>;
 
     fn into_iter(self) -> RawArrayIter<'a> {
         RawArrayIter {
@@ -142,9 +156,9 @@ pub struct RawArrayIter<'a> {
 }
 
 impl<'a> Iterator for RawArrayIter<'a> {
-    type Item = RawResult<elem::RawBson<'a>>;
+    type Item = Result<RawBson<'a>>;
 
-    fn next(&mut self) -> Option<RawResult<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)),