use alloc::vec::Vec; use crate::bstr::BStr; /// A wrapper for `Vec` that provides convenient string oriented trait /// impls. /// /// A `BString` has ownership over its contents and corresponds to /// a growable or shrinkable buffer. Its borrowed counterpart is a /// [`BStr`](struct.BStr.html), called a byte string slice. /// /// Using a `BString` is just like using a `Vec`, since `BString` /// implements `Deref` to `Vec`. So all methods available on `Vec` /// are also available on `BString`. /// /// # Examples /// /// You can create a new `BString` from a `Vec` via a `From` impl: /// /// ``` /// use bstr::BString; /// /// let s = BString::from("Hello, world!"); /// ``` /// /// # Deref /// /// The `BString` type implements `Deref` and `DerefMut`, where the target /// types are `&Vec` and `&mut Vec`, respectively. `Deref` permits all of the /// methods defined on `Vec` to be implicitly callable on any `BString`. /// /// For more information about how deref works, see the documentation for the /// [`std::ops::Deref`](https://doc.rust-lang.org/std/ops/trait.Deref.html) /// trait. /// /// # Representation /// /// A `BString` has the same representation as a `Vec` and a `String`. /// That is, it is made up of three word sized components: a pointer to a /// region of memory containing the bytes, a length and a capacity. #[derive(Clone, Hash)] pub struct BString { bytes: Vec, } impl BString { /// Constructs a new `BString` from the given [`Vec`]. /// /// # Examples /// /// ``` /// use bstr::BString; /// /// let mut b = BString::new(Vec::with_capacity(10)); /// ``` /// /// This function is `const`: /// /// ``` /// use bstr::BString; /// /// const B: BString = BString::new(vec![]); /// ``` #[inline] pub const fn new(bytes: Vec) -> BString { BString { bytes } } #[inline] pub(crate) fn as_bytes(&self) -> &[u8] { &self.bytes } #[inline] pub(crate) fn as_bytes_mut(&mut self) -> &mut [u8] { &mut self.bytes } #[inline] pub(crate) fn as_bstr(&self) -> &BStr { BStr::new(&self.bytes) } #[inline] pub(crate) fn as_mut_bstr(&mut self) -> &mut BStr { BStr::new_mut(&mut self.bytes) } #[inline] pub(crate) fn as_vec(&self) -> &Vec { &self.bytes } #[inline] pub(crate) fn as_vec_mut(&mut self) -> &mut Vec { &mut self.bytes } #[inline] pub(crate) fn into_vec(self) -> Vec { self.bytes } }