use alloc::borrow::Cow; use alloc::string::String; use alloc::vec::Vec; use core::fmt; /// A byte slice. /// /// Uses copy-on-write to avoid unnecessary allocations. The bytes can be /// accessed as a slice using the `Deref` trait, or as a mutable `Vec` using the /// `to_mut` method. /// /// Provides a `Debug` implementation that shows the first 8 bytes and the length. #[derive(Default, Clone, PartialEq, Eq)] pub struct Bytes<'a>(Cow<'a, [u8]>); impl<'a> Bytes<'a> { /// Acquire a mutable reference to the bytes. /// /// Clones the bytes if they are shared. pub fn to_mut(&mut self) -> &mut Vec { self.0.to_mut() } /// Get the bytes as a slice. pub fn as_slice(&self) -> &[u8] { self.0.as_ref() } } impl<'a> core::ops::Deref for Bytes<'a> { type Target = [u8]; fn deref(&self) -> &[u8] { self.0.deref() } } impl<'a> From<&'a [u8]> for Bytes<'a> { fn from(bytes: &'a [u8]) -> Self { Bytes(Cow::Borrowed(bytes)) } } impl<'a> From> for Bytes<'a> { fn from(bytes: Vec) -> Self { Bytes(Cow::Owned(bytes)) } } impl<'a> fmt::Debug for Bytes<'a> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { debug_list_bytes(&self.0, f) } } // Only for Debug impl of `Bytes`. fn debug_list_bytes(bytes: &[u8], fmt: &mut fmt::Formatter<'_>) -> fmt::Result { let mut list = fmt.debug_list(); list.entries(bytes.iter().take(8).copied().map(DebugByte)); if bytes.len() > 8 { list.entry(&DebugLen(bytes.len())); } list.finish() } struct DebugByte(u8); impl fmt::Debug for DebugByte { fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { write!(fmt, "0x{:02x}", self.0) } } struct DebugLen(usize); impl fmt::Debug for DebugLen { fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { write!(fmt, "...; {}", self.0) } } /// A byte slice that is a string of an unknown encoding. /// /// Uses copy-on-write to avoid unnecessary allocations. The bytes can be /// accessed as a slice using the `Deref` trait, or as a mutable `Vec` using the /// `to_mut` method. /// /// Provides a `Debug` implementation that interprets the bytes as UTF-8. #[derive(Default, Clone, PartialEq, Eq, Hash)] pub struct ByteString<'a>(Cow<'a, [u8]>); impl<'a> ByteString<'a> { /// Acquire a mutable reference to the bytes. /// /// Clones the bytes if they are shared. pub fn to_mut(&mut self) -> &mut Vec { self.0.to_mut() } /// Get the bytes as a slice. pub fn as_slice(&self) -> &[u8] { self.0.as_ref() } } impl<'a> core::borrow::Borrow<[u8]> for ByteString<'a> { fn borrow(&self) -> &[u8] { self.0.borrow() } } impl<'a> core::ops::Deref for ByteString<'a> { type Target = [u8]; fn deref(&self) -> &[u8] { self.0.deref() } } impl<'a> From<&'a [u8]> for ByteString<'a> { fn from(bytes: &'a [u8]) -> Self { ByteString(Cow::Borrowed(bytes)) } } impl<'a> From> for ByteString<'a> { fn from(bytes: Vec) -> Self { ByteString(Cow::Owned(bytes)) } } impl<'a> From<&'a str> for ByteString<'a> { fn from(s: &'a str) -> Self { ByteString(Cow::Borrowed(s.as_bytes())) } } impl<'a> fmt::Debug for ByteString<'a> { fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { write!(fmt, "\"{}\"", String::from_utf8_lossy(&self.0)) } } impl<'a> fmt::Display for ByteString<'a> { fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { write!(fmt, "{}", String::from_utf8_lossy(&self.0)) } }