bson/raw/

array_buf.rs

use std::{
    borrow::{Borrow, Cow},
    fmt::Debug,
};

use crate::{RawArray, RawBsonRef, RawDocumentBuf};

use super::{document_buf::BindRawBsonRef, RawArrayIter};

/// An owned BSON array value (akin to [`std::path::PathBuf`]), backed by a buffer of raw BSON
/// bytes. This type can be used to construct owned array values, which can be used to append to
/// [`RawDocumentBuf`] or as a field in a [`Deserialize`](serde::Deserialize) struct.
///
/// Iterating over a [`RawArrayBuf`] yields either an error or a [`RawBson`](crate::raw::RawBson)
/// value that borrows from the original document without making any additional allocations.
/// ```
/// # use bson::error::Error;
/// use bson::raw::RawArrayBuf;
///
/// let mut array = RawArrayBuf::new();
/// array.push("a string");
/// array.push(12_i32);
///
/// let mut iter = array.into_iter();
///
/// let value = iter.next().unwrap()?;
/// assert_eq!(value.as_str(), Some("a string"));
///
/// let value = iter.next().unwrap()?;
/// assert_eq!(value.as_i32(), Some(12));
///
/// assert!(iter.next().is_none());
/// # Ok::<(), Error>(())
/// ```
///
/// This type implements [`Deref`](std::ops::Deref) to [`RawArray`], meaning that all methods on
/// [`RawArray`] are available on [`RawArrayBuf`] values as well. This includes [`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 document
/// from the beginning to find the requested key.
#[derive(Clone, PartialEq)]
pub struct RawArrayBuf {
    inner: RawDocumentBuf,
    len: usize,
}

impl RawArrayBuf {
    /// Construct a new, empty [`RawArrayBuf`].
    pub fn new() -> RawArrayBuf {
        Self {
            inner: RawDocumentBuf::new(),
            len: 0,
        }
    }

    /// Construct a new [`RawArrayBuf`] from the provided [`Vec`] of bytes.
    ///
    /// This involves a traversal of the array to count the values.
    pub(crate) fn from_raw_document_buf(doc: RawDocumentBuf) -> Self {
        let len = doc.iter().count();
        Self { inner: doc, len }
    }

    /// Append a value to the end of the array.
    ///
    /// ```
    /// # use bson::error::Error;
    /// use bson::raw::{cstr, RawArrayBuf, RawDocumentBuf};
    ///
    /// let mut array = RawArrayBuf::new();
    /// array.push("a string");
    /// array.push(12_i32);
    ///
    /// let mut doc = RawDocumentBuf::new();
    /// doc.append(cstr!("a key"), "a value");
    /// array.push(doc.clone());
    ///
    /// let mut iter = array.into_iter();
    ///
    /// let value = iter.next().unwrap()?;
    /// assert_eq!(value.as_str(), Some("a string"));
    ///
    /// let value = iter.next().unwrap()?;
    /// assert_eq!(value.as_i32(), Some(12));
    ///
    /// let value = iter.next().unwrap()?;
    /// assert_eq!(value.as_document(), Some(doc.as_ref()));
    ///
    /// assert!(iter.next().is_none());
    /// # Ok::<(), Error>(())
    /// ```
    pub fn push(&mut self, value: impl BindRawBsonRef) {
        self.inner.append(
            super::CString::from_string_unchecked(self.len.to_string()),
            value,
        );
        self.len += 1;
    }
}

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
    }
}

impl Debug for RawArrayBuf {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("RawArrayBuf")
            .field("data", &hex::encode(self.as_bytes()))
            .field("len", &self.len)
            .finish()
    }
}

impl std::ops::Deref for RawArrayBuf {
    type Target = RawArray;

    fn deref(&self) -> &Self::Target {
        RawArray::from_doc(&self.inner)
    }
}

impl AsRef<RawArray> for RawArrayBuf {
    fn as_ref(&self) -> &RawArray {
        RawArray::from_doc(&self.inner)
    }
}

impl Borrow<RawArray> for RawArrayBuf {
    fn borrow(&self) -> &RawArray {
        self.as_ref()
    }
}

impl<'a> IntoIterator for &'a RawArrayBuf {
    type IntoIter = RawArrayIter<'a>;
    type Item = super::Result<RawBsonRef<'a>>;

    fn into_iter(self) -> RawArrayIter<'a> {
        self.as_ref().into_iter()
    }
}

impl From<RawArrayBuf> for Cow<'_, RawArray> {
    fn from(rd: RawArrayBuf) -> Self {
        Cow::Owned(rd)
    }
}

impl<'a> From<&'a RawArrayBuf> for Cow<'a, RawArray> {
    fn from(rd: &'a RawArrayBuf) -> Self {
        Cow::Borrowed(rd.as_ref())
    }
}

#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for RawArrayBuf {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        Ok(super::serde::OwnedOrBorrowedRawArray::deserialize(deserializer)?.into_owned())
    }
}

#[cfg(feature = "serde")]
impl serde::Serialize for RawArrayBuf {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        self.as_ref().serialize(serializer)
    }
}

impl Default for RawArrayBuf {
    fn default() -> Self {
        Self::new()
    }
}

impl TryFrom<&crate::Array> for RawArrayBuf {
    type Error = crate::error::Error;

    fn try_from(value: &crate::Array) -> Result<Self, Self::Error> {
        Self::try_from(value.clone())
    }
}

impl TryFrom<crate::Array> for RawArrayBuf {
    type Error = crate::error::Error;

    fn try_from(value: crate::Array) -> Result<Self, Self::Error> {
        let mut tmp = RawArrayBuf::new();
        for val in value {
            let raw: super::RawBson = val.try_into()?;
            tmp.push(raw);
        }
        Ok(tmp)
    }
}