cstr append key

Author: abr-egn

src/macros.rs

@@ -240,12 +240,12 @@ macro_rules! rawbson {
 
     // Finished with trailing comma.
     (@array [$($elems:expr,)*]) => {
-        $crate::RawArrayBuf::from_iter(vec![$($elems,)*]).expect("invalid bson value")
+        $crate::RawArrayBuf::from_iter(vec![$($elems,)*])
     };
 
     // Finished without trailing comma.
     (@array [$($elems:expr),*]) => {
-        $crate::RawArrayBuf::from_iter(vec![$($elems),*]).expect("invalid bson value")
+        $crate::RawArrayBuf::from_iter(vec![$($elems),*])
     };
 
     // Next element is `null`.
@@ -292,14 +292,18 @@ macro_rules! rawbson {
     (@object $object:ident () () ()) => {};
 
     // Insert the current entry followed by trailing comma.
-    (@object $object:ident [$($key:tt)+] ($value:expr) , $($rest:tt)*) => {
-        $object.append(($($key)+), $value).expect("invalid bson value");
+    (@object $object:ident [$($key:tt)+] ($value:expr) , $($rest:tt)*) => {{
+        let key: &str = ($($key)+).as_ref();
+        let key: &$crate::raw::CStr = key.try_into().expect("invalid key");
+        $object.append(key, $value);
         $crate::rawbson!(@object $object () ($($rest)*) ($($rest)*));
-    };
+    }};
 
     // Insert the last entry without trailing comma.
     (@object $object:ident [$($key:tt)+] ($value:expr)) => {
-        $object.append(($($key)+), $value).expect("invalid bson value");
+        let key: &str = ($($key)+).as_ref();
+        let key: &$crate::raw::CStr = key.try_into().expect("invalid key");
+        $object.append(key, $value);
     };
 
     // Next value is `null`.

src/raw/array_buf.rs

@@ -53,19 +53,6 @@ impl RawArrayBuf {
         }
     }
 
-    #[allow(clippy::should_implement_trait)]
-    pub fn from_iter<B, I>(iter: I) -> crate::error::Result<Self>
-    where
-        B: BindRawBsonRef,
-        I: IntoIterator<Item = B>,
-    {
-        let mut array_buf = RawArrayBuf::new();
-        for item in iter {
-            array_buf.push(item)?;
-        }
-        Ok(array_buf)
-    }
-
     /// Construct a new [`RawArrayBuf`] from the provided [`Vec`] of bytes.
     ///
     /// This involves a traversal of the array to count the values.
@@ -102,10 +89,22 @@ impl RawArrayBuf {
     /// assert!(iter.next().is_none());
     /// # Ok::<(), Error>(())
     /// ```
-    pub fn push(&mut self, value: impl BindRawBsonRef) -> crate::error::Result<()> {
-        self.inner.append(self.len.to_string(), value)?;
+    pub fn push(&mut self, value: impl BindRawBsonRef) {
+        self.inner.append(
+            super::CString::from_string_unchecked(self.len.to_string()),
+            value,
+        );
         self.len += 1;
-        Ok(())
+    }
+}
+
+impl<B: BindRawBsonRef> FromIterator<B> for RawArrayBuf {
+    fn from_iter<T: IntoIterator<Item = B>>(iter: T) -> Self {
+        let mut array_buf = RawArrayBuf::new();
+        for item in iter {
+            array_buf.push(item);
+        }
+        array_buf
     }
 }
 
@@ -200,7 +199,7 @@ impl TryFrom<crate::Array> for RawArrayBuf {
         let mut tmp = RawArrayBuf::new();
         for val in value {
             let raw: super::RawBson = val.try_into()?;
-            tmp.push(raw)?;
+            tmp.push(raw);
         }
         Ok(tmp)
     }

src/raw/bson_ref.rs

@@ -261,7 +261,7 @@ impl<'a> RawBsonRef<'a> {
                 let options: String = chars.into_iter().collect();
                 RawBson::RegularExpression(Regex {
                     pattern: re.pattern.into(),
-                    options: super::CString::from_unchecked(options),
+                    options: super::CString::from_string_unchecked(options),
                 })
             }
             RawBsonRef::JavaScriptCode(c) => RawBson::JavaScriptCode(c.to_owned()),

src/raw/cstr.rs

@@ -59,6 +59,12 @@ impl std::borrow::ToOwned for CStr {
     }
 }
 
+impl AsRef<CStr> for CStr {
+    fn as_ref(&self) -> &CStr {
+        self
+    }
+}
+
 #[cfg(feature = "serde")]
 impl serde::Serialize for &CStr {
     fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
@@ -123,7 +129,7 @@ impl TryFrom<&str> for CString {
 }
 
 impl CString {
-    pub(crate) fn from_unchecked(data: String) -> Self {
+    pub(crate) fn from_string_unchecked(data: String) -> Self {
         Self { data }
     }
 

src/raw/document_buf.rs

@@ -4,7 +4,10 @@ use std::{
     ops::Deref,
 };
 
-use crate::{raw::MIN_BSON_DOCUMENT_SIZE, Document};
+use crate::{
+    raw::{CStr, MIN_BSON_DOCUMENT_SIZE},
+    Document,
+};
 
 use super::{bson::RawBson, iter::Iter, RawBsonRef, RawDocument, RawIter, Result};
 
@@ -87,20 +90,6 @@ impl RawDocumentBuf {
         Self::decode_from_bytes(buf)
     }
 
-    #[allow(clippy::should_implement_trait)]
-    pub fn from_iter<S, B, I>(iter: I) -> Result<Self>
-    where
-        S: AsRef<str>,
-        B: BindRawBsonRef,
-        I: IntoIterator<Item = (S, B)>,
-    {
-        let mut buf = RawDocumentBuf::new();
-        for (k, v) in iter {
-            buf.append(k, v)?;
-        }
-        Ok(buf)
-    }
-
     /// Create a [`RawDocumentBuf`] from a [`Document`].
     ///
     /// ```
@@ -117,8 +106,9 @@ impl RawDocumentBuf {
     pub fn from_document(doc: impl Borrow<Document>) -> Result<Self> {
         let mut out = RawDocumentBuf::new();
         for (k, v) in doc.borrow() {
+            let k: &CStr = k.as_str().try_into()?;
             let val: RawBson = v.clone().try_into()?;
-            out.append(k, val)?;
+            out.append(k, val);
         }
         Ok(out)
     }
@@ -215,14 +205,19 @@ impl RawDocumentBuf {
     /// assert_eq!(doc.to_document()?, expected);
     /// # Ok::<(), Error>(())
     /// ```
-    pub fn append(
-        &mut self,
-        key: impl AsRef<str>,
-        value: impl BindRawBsonRef,
-    ) -> crate::error::Result<()> {
-        let key = key.as_ref().try_into()?;
-        Ok(value
-            .bind(|value_ref| raw_writer::RawWriter::new(&mut self.data).append(key, value_ref)))
+    pub fn append(&mut self, key: impl AsRef<CStr>, value: impl BindRawBsonRef) {
+        let key = key.as_ref();
+        value.bind(|value_ref| raw_writer::RawWriter::new(&mut self.data).append(key, value_ref));
+    }
+}
+
+impl<K: AsRef<CStr>, B: BindRawBsonRef> FromIterator<(K, B)> for RawDocumentBuf {
+    fn from_iter<T: IntoIterator<Item = (K, B)>>(iter: T) -> Self {
+        let mut buf = RawDocumentBuf::new();
+        for (k, v) in iter {
+            buf.append(k, v);
+        }
+        buf
     }
 }
 
@@ -287,8 +282,9 @@ impl TryFrom<Document> for RawDocumentBuf {
     fn try_from(doc: Document) -> std::result::Result<Self, Self::Error> {
         let mut out = RawDocumentBuf::new();
         for (k, v) in doc {
+            let k: &CStr = k.as_str().try_into()?;
             let val: RawBson = v.try_into()?;
-            out.append(k, val)?;
+            out.append(k, val);
         }
         Ok(out)
     }