non-serde conversion

Author: abr-egn

src/bson.rs

@@ -31,7 +31,7 @@ use std::{
 use serde_json::{json, Value};
 
 pub use crate::document::Document;
-use crate::{base64, oid, spec::ElementType, Binary, Decimal128};
+use crate::{base64, oid, raw::CString, spec::ElementType, Binary, Decimal128};
 
 /// Possible BSON value types.
 #[derive(Clone, Default, PartialEq)]
@@ -480,14 +480,14 @@ impl Bson {
             Bson::Boolean(v) => json!(v),
             Bson::Null => Value::Null,
             Bson::RegularExpression(Regex { pattern, options }) => {
-                let mut chars: Vec<_> = options.chars().collect();
+                let mut chars: Vec<_> = options.as_str().chars().collect();
                 chars.sort_unstable();
 
                 let options: String = chars.into_iter().collect();
 
                 json!({
                     "$regularExpression": {
-                        "pattern": pattern,
+                        "pattern": pattern.into_string(),
                         "options": options,
                     }
                 })
@@ -1147,7 +1147,7 @@ impl Timestamp {
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub struct Regex {
     /// The regex pattern to match.
-    pub pattern: String,
+    pub pattern: CString,
 
     /// The options for the regex.
     ///
@@ -1156,18 +1156,22 @@ pub struct Regex {
     /// multiline matching, 'x' for verbose mode, 'l' to make \w, \W, etc. locale dependent,
     /// 's' for dotall mode ('.' matches everything), and 'u' to make \w, \W, etc. match
     /// unicode.
-    pub options: String,
+    pub options: CString,
 }
 
 impl Regex {
-    pub(crate) fn new(pattern: impl AsRef<str>, options: impl AsRef<str>) -> Self {
+    #[cfg(test)]
+    pub(crate) fn new(
+        pattern: impl AsRef<str>,
+        options: impl AsRef<str>,
+    ) -> crate::error::Result<Self> {
         let mut chars: Vec<_> = options.as_ref().chars().collect();
         chars.sort_unstable();
         let options: String = chars.into_iter().collect();
-        Self {
-            pattern: pattern.as_ref().to_string(),
-            options,
-        }
+        Ok(Self {
+            pattern: pattern.as_ref().to_string().try_into()?,
+            options: options.try_into()?,
+        })
     }
 }
 

src/raw.rs

@@ -116,6 +116,7 @@ mod array;
 mod array_buf;
 mod bson;
 mod bson_ref;
+mod cstr;
 mod document;
 mod document_buf;
 mod iter;
@@ -142,6 +143,7 @@ pub use self::{
         RawJavaScriptCodeWithScopeRef,
         RawRegexRef,
     },
+    cstr::{assert_valid_cstr, cstr, validate_cstr, CStr, CString, IsValidCStr},
     document::RawDocument,
     document_buf::{BindRawBsonRef, BindValue, RawDocumentBuf},
     iter::{RawElement, RawIter},

src/raw/bson.rs

@@ -204,8 +204,8 @@ impl RawBson {
     pub fn as_regex(&self) -> Option<RawRegexRef<'_>> {
         match self {
             RawBson::RegularExpression(v) => Some(RawRegexRef {
-                pattern: v.pattern.as_str(),
-                options: v.options.as_str(),
+                pattern: v.pattern.as_ref(),
+                options: v.options.as_ref(),
             }),
             _ => None,
         }
@@ -289,8 +289,8 @@ impl RawBson {
             RawBson::Boolean(b) => RawBsonRef::Boolean(*b),
             RawBson::Null => RawBsonRef::Null,
             RawBson::RegularExpression(re) => RawBsonRef::RegularExpression(RawRegexRef {
-                options: re.options.as_str(),
-                pattern: re.pattern.as_str(),
+                options: re.options.as_ref(),
+                pattern: re.pattern.as_ref(),
             }),
             RawBson::JavaScriptCode(c) => RawBsonRef::JavaScriptCode(c.as_str()),
             RawBson::JavaScriptCodeWithScope(code_w_scope) => {

src/raw/bson_ref.rs

@@ -3,7 +3,7 @@ use std::convert::{TryFrom, TryInto};
 use super::{bson::RawBson, Error, RawArray, RawDocument, Result};
 use crate::{
     oid::{self, ObjectId},
-    raw::{write_cstring, write_string, RawJavaScriptCodeWithScope},
+    raw::{write_string, CStr, RawJavaScriptCodeWithScope},
     spec::{BinarySubtype, ElementType},
     Binary,
     Bson,
@@ -255,9 +255,10 @@ impl<'a> RawBsonRef<'a> {
             RawBsonRef::Document(d) => RawBson::Document(d.to_owned()),
             RawBsonRef::Boolean(b) => RawBson::Boolean(b),
             RawBsonRef::Null => RawBson::Null,
-            RawBsonRef::RegularExpression(re) => {
-                RawBson::RegularExpression(Regex::new(re.pattern, re.options))
-            }
+            RawBsonRef::RegularExpression(re) => RawBson::RegularExpression(Regex {
+                pattern: re.pattern.into(),
+                options: re.options.into(),
+            }),
             RawBsonRef::JavaScriptCode(c) => RawBson::JavaScriptCode(c.to_owned()),
             RawBsonRef::JavaScriptCodeWithScope(c_w_s) => {
                 RawBson::JavaScriptCodeWithScope(RawJavaScriptCodeWithScope {
@@ -306,8 +307,8 @@ impl<'a> RawBsonRef<'a> {
             Self::Document(raw_document) => dest.extend(raw_document.as_bytes()),
             Self::Boolean(b) => dest.push(b as u8),
             Self::RegularExpression(re) => {
-                write_cstring(dest, re.pattern)?;
-                write_cstring(dest, re.options)?;
+                re.pattern.append_to(dest);
+                re.options.append_to(dest);
             }
             Self::JavaScriptCode(js) => write_string(dest, js),
             Self::JavaScriptCodeWithScope(code_w_scope) => {
@@ -592,7 +593,7 @@ impl<'a> From<&'a Binary> for RawBsonRef<'a> {
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct RawRegexRef<'a> {
     /// The regex pattern to match.
-    pub pattern: &'a str,
+    pub pattern: &'a CStr,
 
     /// The options for the regex.
     ///
@@ -601,7 +602,7 @@ pub struct RawRegexRef<'a> {
     /// multiline matching, 'x' for verbose mode, 'l' to make \w, \W, etc. locale dependent,
     /// 's' for dotall mode ('.' matches everything), and 'u' to make \w, \W, etc. match
     /// unicode.
-    pub options: &'a str,
+    pub options: &'a CStr,
 }
 
 #[cfg(feature = "serde")]

src/raw/cstr.rs

@@ -0,0 +1,132 @@
+use core::str;
+
+use crate::error::{Error, Result};
+
+// A BSON-spec cstring: Zero or more UTF-8 encoded characters, excluding the null byte.
+#[derive(Debug)]
+#[repr(transparent)]
+pub struct CStr {
+    data: [u8],
+}
+
+impl<'a> TryFrom<&'a str> for &'a CStr {
+    type Error = Error;
+
+    fn try_from(value: &str) -> Result<&CStr> {
+        match validate_cstr(value) {
+            Some(cs) => Ok(cs),
+            None => Err(Error::malformed_bytes(format!(
+                "cstring with interior null: {:?}",
+                value,
+            ))),
+        }
+    }
+}
+
+impl CStr {
+    const fn from_str_unchecked(value: &str) -> &Self {
+        // Safety: the conversion is safe because CStr is repr(transparent), and the deref is safe
+        // because the pointer came from a safe reference.
+        unsafe { &*(value.as_bytes() as *const [u8] as *const CStr) }
+    }
+
+    pub fn as_str(&self) -> &str {
+        // Safety: the only way to constrct a CStr is from a valid &str.
+        unsafe { str::from_utf8_unchecked(&self.data) }
+    }
+
+    pub fn len(&self) -> usize {
+        self.as_str().len()
+    }
+
+    pub(crate) fn append_to(&self, buf: &mut Vec<u8>) {
+        buf.extend(&self.data);
+        buf.push(0);
+    }
+}
+
+impl<'a, 'b> PartialEq<&'b CStr> for &'a CStr {
+    fn eq(&self, other: &&CStr) -> bool {
+        self.as_str() == other.as_str()
+    }
+}
+
+#[diagnostic::on_unimplemented(message = "the string literal contains a zero byte")]
+pub trait ValidCStr {}
+pub struct IsValidCStr<const VALID: bool>;
+impl ValidCStr for IsValidCStr<true> {}
+
+#[derive(Clone, Eq, PartialEq, Hash)]
+#[repr(transparent)]
+pub struct CString {
+    data: String,
+}
+
+pub const fn validate_cstr(text: &str) -> Option<&CStr> {
+    let bytes = text.as_bytes();
+    let mut i = 0;
+    while i < bytes.len() {
+        if bytes[i] == 0 {
+            return None;
+        }
+        i += 1;
+    }
+    Some(CStr::from_str_unchecked(text))
+}
+pub const fn assert_valid_cstr<T: ValidCStr>() {}
+
+#[macro_export]
+macro_rules! cstr {
+    ($text:expr) => {{
+        const VALIDATED: Option<&$crate::raw::CStr> = $crate::raw::validate_cstr($text);
+        const VALID: bool = VALIDATED.is_some();
+        $crate::raw::assert_valid_cstr::<$crate::raw::IsValidCStr<VALID>>();
+        VALIDATED.unwrap()
+    }};
+}
+pub use cstr;
+
+impl TryFrom<String> for CString {
+    type Error = Error;
+
+    fn try_from(data: String) -> Result<Self> {
+        let _: &CStr = data.as_str().try_into()?;
+        Ok(Self { data })
+    }
+}
+
+impl CString {
+    pub fn into_string(self) -> String {
+        self.data
+    }
+
+    pub fn as_str(&self) -> &str {
+        self.as_ref().as_str()
+    }
+}
+
+impl From<&CStr> for CString {
+    fn from(value: &CStr) -> Self {
+        Self {
+            data: value.as_str().into(),
+        }
+    }
+}
+
+impl AsRef<CStr> for CString {
+    fn as_ref(&self) -> &CStr {
+        CStr::from_str_unchecked(self.data.as_str())
+    }
+}
+
+impl std::fmt::Debug for CString {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.data.fmt(f)
+    }
+}
+
+impl std::fmt::Display for CString {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.data.fmt(f)
+    }
+}

src/raw/document.rs

@@ -5,6 +5,7 @@ use std::{
 
 use crate::{
     error::{Error, Result},
+    raw::CStr,
     Bson,
     DateTime,
     JavaScriptCodeWithScope,
@@ -505,9 +506,10 @@ impl RawDocument {
         }
     }
 
-    pub(crate) fn read_cstring_at(&self, start_at: usize) -> RawResult<&str> {
+    pub(crate) fn read_cstring_at(&self, start_at: usize) -> RawResult<&CStr> {
         let bytes = self.cstring_bytes_at(start_at)?;
-        try_to_str(bytes)
+        let s = try_to_str(bytes)?;
+        s.try_into()
     }
 
     /// Copy this into a [`Document`], returning an error if invalid BSON is encountered.

src/raw/iter.rs

@@ -2,7 +2,7 @@ use std::convert::TryInto;
 
 use crate::{
     oid::ObjectId,
-    raw::{Error, Result, MIN_BSON_DOCUMENT_SIZE, MIN_CODE_WITH_SCOPE_SIZE},
+    raw::{CStr, Error, Result, MIN_BSON_DOCUMENT_SIZE, MIN_CODE_WITH_SCOPE_SIZE},
     spec::{BinarySubtype, ElementType},
     Bson,
     DateTime,
@@ -50,7 +50,7 @@ impl<'a> Iterator for Iter<'a> {
         match self.inner.next() {
             Some(Ok(elem)) => match elem.value() {
                 Err(e) => Some(Err(e)),
-                Ok(value) => Some(Ok((elem.key, value))),
+                Ok(value) => Some(Ok((elem.key.as_str(), value))),
             },
             Some(Err(e)) => Some(Err(e)),
             None => None,
@@ -111,7 +111,7 @@ impl<'a> RawIter<'a> {
 
 #[derive(Clone)]
 pub struct RawElement<'a> {
-    key: &'a str,
+    key: &'a CStr,
     kind: ElementType,
     doc: &'a RawDocument,
     start_at: usize,
@@ -160,7 +160,7 @@ impl<'a> RawElement<'a> {
     }
 
     pub fn key(&self) -> &'a str {
-        self.key
+        self.key.as_str()
     }
 
     pub fn element_type(&self) -> ElementType {
@@ -305,19 +305,20 @@ impl<'a> RawElement<'a> {
                     String::from_utf8_lossy(self.doc.cstring_bytes_at(self.start_at)?).into_owned();
                 let pattern_len = pattern.len();
                 Utf8LossyBson::RegularExpression(crate::Regex {
-                    pattern,
+                    pattern: pattern.try_into()?,
                     options: String::from_utf8_lossy(
                         self.doc.cstring_bytes_at(self.start_at + pattern_len + 1)?,
                     )
-                    .into_owned(),
+                    .into_owned()
+                    .try_into()?,
                 })
             }
             _ => return Ok(None),
         }))
     }
 
     fn malformed_error(&self, e: impl ToString) -> Error {
-        Error::malformed_bytes(e).with_key(self.key)
+        Error::malformed_bytes(e).with_key(self.key.as_str())
     }
 
     pub(crate) fn slice(&self) -> &'a [u8] {
@@ -344,7 +345,7 @@ impl<'a> RawElement<'a> {
         Ok(ObjectId::from_bytes(
             self.doc.as_bytes()[start_at..(start_at + 12)]
                 .try_into()
-                .map_err(|e| Error::malformed_bytes(e).with_key(self.key))?,
+                .map_err(|e| Error::malformed_bytes(e).with_key(self.key.as_str()))?,
         ))
     }
 }
@@ -443,7 +444,7 @@ impl<'a> Iterator for RawIter<'a> {
             }),
             Err(error) => {
                 self.valid = false;
-                Err(error.with_key(key))
+                Err(error.with_key(key.as_str()))
             }
         })
     }