summaryrefslogtreecommitdiffstats
path: root/vendor/byteyarn/src/reffed.rs
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/byteyarn/src/reffed.rs')
-rw-r--r--vendor/byteyarn/src/reffed.rs410
1 files changed, 0 insertions, 410 deletions
diff --git a/vendor/byteyarn/src/reffed.rs b/vendor/byteyarn/src/reffed.rs
deleted file mode 100644
index a988b4085..000000000
--- a/vendor/byteyarn/src/reffed.rs
+++ /dev/null
@@ -1,410 +0,0 @@
-use std::cmp::Ordering;
-use std::fmt;
-use std::fmt::Write;
-use std::hash::Hash;
-use std::hash::Hasher;
-use std::marker::PhantomData;
-use std::mem;
-use std::ops::Deref;
-use std::str;
-use std::str::Utf8Error;
-
-use crate::raw::RawYarn;
-use crate::Utf8Chunks;
-use crate::YarnBox;
-
-#[cfg(doc)]
-use crate::*;
-
-/// An optimized, freely copyable string type.
-///
-/// Like a [`Yarn`], but [`Copy`].
-///
-/// In general, prefer to use [`Yarn`] except when you absolutely need the type
-/// to be [`Copy`]. [`YarnRef`] is very similar to [`Yarn`], although it can't
-/// provide full functionality because it can't own a heap allocation.
-///
-/// See the [crate documentation](crate) for general information.
-#[repr(transparent)]
-pub struct YarnRef<'a, Buf>
-where
- Buf: crate::Buf + ?Sized,
-{
- raw: RawYarn,
- _ph: PhantomData<&'a Buf>,
-}
-
-impl<'a, Buf> YarnRef<'a, Buf>
-where
- Buf: crate::Buf + ?Sized,
-{
- pub(crate) const fn buf2raw(buf: &Buf) -> &[u8] {
- let ptr = &buf as *const &Buf as *const &[u8];
- unsafe {
- // SAFETY: The safety rules of `Buf` make this valid.
- *ptr
- }
- }
-
- pub(crate) const unsafe fn raw2buf(buf: &[u8]) -> &Buf {
- let ptr = &buf as *const &[u8] as *const &Buf;
- *ptr
- }
-
- pub(crate) const unsafe fn from_raw(raw: RawYarn) -> Self {
- debug_assert!(!raw.on_heap());
- Self {
- raw,
- _ph: PhantomData,
- }
- }
-
- /// Returns a reference to an empty yarn of any lifetime.
- ///
- /// ```
- /// # use byteyarn::*;
- /// let empty: &YarnRef<str> = YarnRef::empty();
- /// assert_eq!(empty, "");
- /// ```
- ///
- /// This will also be found by the `Default` impl for `&YarnRef`.
- pub fn empty<'b>() -> &'b Self {
- unsafe {
- // SAFETY: YarnRef is a transparent wrapper over RawYarn; even though
- // YarnRef has a destructor, this is fine.
- mem::transmute::<&'b RawYarn, &'b Self>(RawYarn::empty())
- }
- }
-
- /// Returns a yarn pointing to the given slice, without copying.
- ///
- /// ```
- /// # use byteyarn::*;
- /// let foo = YarnRef::new("Byzantium");
- /// assert_eq!(foo.len(), 9);
- /// ```
- pub const fn new(buf: &'a Buf) -> Self {
- unsafe {
- // SAFETY: We copy the lifetime from buf into self, so this alias slice
- // must go away before buf can.
- let raw = RawYarn::alias_slice(Self::buf2raw(buf));
-
- // SAFETY: buf is a valid slice by construction, and alias_slice() never
- // returns a HEAP yarn.
- Self::from_raw(raw)
- }
- }
-
- /// Returns a new yarn containing the contents of the given slice.
- /// This function will always return an inlined string, or `None` if the
- /// given buffer is too big.
- ///
- /// Note that the maximum inlined size is architecture-dependent.
- ///
- /// ```
- /// # use byteyarn::*;
- /// let smol = YarnRef::inlined("smol");
- /// assert_eq!(smol.unwrap(), "smol");
- ///
- /// let big = YarnRef::inlined("biiiiiiiiiiiiiiig");
- /// assert!(big.is_none());
- /// ```
- pub const fn inlined(buf: &Buf) -> Option<Self> {
- // This is a const fn, hence no ?.
- let Some(raw) = RawYarn::from_slice_inlined(Self::buf2raw(buf)) else {
- return None;
- };
-
- unsafe {
- // SAFETY: from_slice_inlined() always returns a SMALL yarn.
- Some(Self::from_raw(raw))
- }
- }
-
- /// Returns a yarn containing a single UTF-8-encoded Unicode scalar.
- /// This function does not allocate: every `char` fits in an inlined yarn.
- ///
- /// ```
- /// # use byteyarn::*;
- /// let a = YarnRef::<str>::from_char('a');
- /// assert_eq!(a, "a");
- /// ```
- pub const fn from_char(c: char) -> Self {
- let raw = RawYarn::from_char(c);
- unsafe {
- // SAFETY: from_char() always returns a SMALL yarn.
- Self::from_raw(raw)
- }
- }
-
- /// Checks whether this yarn is empty.
- pub const fn is_empty(self) -> bool {
- self.len() == 0
- }
-
- /// Returns the length of this yarn, in bytes.
- pub const fn len(self) -> usize {
- self.raw.len()
- }
-
- /// Converts this yarn into a slice.
- pub const fn as_slice(&self) -> &Buf {
- unsafe { Self::raw2buf(self.as_bytes()) }
- }
-
- /// Converts this yarn into a byte slice.
- pub const fn as_bytes(&self) -> &[u8] {
- self.raw.as_slice()
- }
-
- /// Converts this reference yarn into a owning yarn of the same lifetime.
- ///
- /// This function does not make copies or allocations.
- pub const fn to_box(self) -> YarnBox<'a, Buf> {
- unsafe {
- // SAFETY: self is never HEAP, and the output lifetime is the same as the
- // input so if self is ALIASED it will not become invalid before the
- // returned yarn goes out of scope.
- YarnBox::from_raw(self.raw)
- }
- }
-
- /// Converts this yarn into a boxed slice by copying it.
- pub fn to_boxed_bytes(self) -> Box<[u8]> {
- self.to_box().into_boxed_bytes()
- }
-
- /// Converts this yarn into a vector by copying it.
- pub fn to_vec(self) -> Vec<u8> {
- self.to_box().into_vec()
- }
-
- /// Converts this yarn into a byte yarn.
- pub const fn into_bytes(self) -> YarnRef<'a, [u8]> {
- unsafe {
- // SAFETY: [u8] can be constructed from either str or [u8], so this
- // type parameter change is valid.
- YarnRef::from_raw(self.raw)
- }
- }
-
- /// Extends the lifetime of this yarn if this yarn is dynamically known to
- /// point to immortal memory.
- ///
- /// If it doesn't, this function returns `None`.
- ///
- /// ```
- /// # use byteyarn::*;
- /// let yarn = YarnRef::<[u8]>::from_static(b"crunchcrunchcrunch");
- ///
- /// let immortal: YarnRef<'static, [u8]> = yarn.immortalize().unwrap();
- /// assert_eq!(immortal, b"crunchcrunchcrunch");
- ///
- /// let borrowed = YarnRef::new(&*immortal);
- /// assert!(borrowed.immortalize().is_none());
- /// ```
- pub fn immortalize(self) -> Option<YarnRef<'static, Buf>> {
- if !self.raw.is_immortal() {
- return None;
- }
-
- unsafe {
- // SAFETY: We just checked that self.raw is guaranteed immortal (and
- // can therefore be used for a 'static lifetime).
- Some(YarnRef::<'static, Buf>::from_raw(self.raw))
- }
- }
-
- /// Tries to inline this yarn, if it's small enough.
- ///
- /// This operation has no directly visible side effects, and is only intended
- /// to provide a way to relieve memory pressure. In general, you should not
- /// have to call this function directly.
- pub fn inline_in_place(&mut self) {
- if let Some(inlined) = Self::inlined(self.as_slice()) {
- *self = inlined;
- }
- }
-
- /// Returns an iterator over the UTF-8 (or otherwise) chunks in this string.
- ///
- /// This iterator is also used for the `Debug` and `Display` formatter
- /// implementations.
- ///
- /// ```
- /// # use byteyarn::*;
- /// let yarn = ByteYarn::new(b"abc\xFF\xFE\xFF\xF0\x9F\x90\x88\xE2\x80\x8D\xE2\xAC\x9B!");
- /// let yr = yarn.as_ref();
- /// let chunks = yr.utf8_chunks().collect::<Vec<_>>();
- /// assert_eq!(chunks, [
- /// Ok("abc"),
- /// Err(&[0xff][..]),
- /// Err(&[0xfe][..]),
- /// Err(&[0xff][..]),
- /// Ok("🐈‍⬛!"),
- /// ]);
- ///
- /// assert_eq!(format!("{yarn:?}"), r#""abc\xFF\xFE\xFF🐈\u{200d}⬛!""#);
- /// assert_eq!(format!("{yarn}"), "abc���🐈‍⬛!");
- /// ```
- pub fn utf8_chunks(&self) -> Utf8Chunks {
- Utf8Chunks::new(self.as_bytes())
- }
-}
-
-impl<Buf> YarnRef<'static, Buf>
-where
- Buf: crate::Buf + ?Sized,
-{
- /// Returns a yarn pointing to the given slice, without copying. This function
- /// has the benefit of creating a yarn that remembers that it came from a
- /// static string, meaning that it can be dynamically upcast back to a
- /// `'static` lifetime.
- ///
- /// This function will *not* be found by `From` impls.
- pub const fn from_static(buf: &'static Buf) -> Self {
- let raw = RawYarn::new(Self::buf2raw(buf));
- unsafe { Self::from_raw(raw) }
- }
-}
-
-impl<'a> YarnRef<'a, [u8]> {
- /// Returns a yarn containing a single byte, without allocating.
- ///
- /// This function will be found by `From` impls.
- pub const fn from_byte(c: u8) -> Self {
- let raw = RawYarn::from_byte(c);
- unsafe { Self::from_raw(raw) }
- }
-
- /// Tries to convert this yarn into a UTF-8 yarn via [`str::from_utf8()`].
- ///
- /// ```
- /// # use byteyarn::*;
- /// let yarn = ByteYarn::new(&[0xf0, 0x9f, 0x90, 0x88, 0xe2, 0x80, 0x8d, 0xe2, 0xac, 0x9b]);
- /// assert_eq!(yarn.as_ref().to_utf8().unwrap(), "🐈‍⬛");
- ///
- /// assert!(ByteYarn::from_byte(0xff).as_ref().to_utf8().is_err());
- /// ```
- pub fn to_utf8(self) -> Result<YarnRef<'a, str>, Utf8Error> {
- str::from_utf8(self.as_bytes())?;
- unsafe { Ok(YarnRef::from_raw(self.raw)) }
- }
-}
-
-impl<'a> YarnRef<'a, str> {
- /// Converts this yarn into a string slice.
- pub fn as_str(&self) -> &str {
- self.as_slice()
- }
-
- /// Converts this yarn into a boxed slice by copying it.
- pub fn to_boxed_str(self) -> Box<str> {
- self.to_box().into_boxed_str()
- }
-
- /// Converts this yarn into a string by copying it.
- // This does the same thing as to_string, but more efficiently. :)
- // The clippy diagnostic also seems wrong, because it says something about
- // this method taking &self? Very odd.
- #[allow(clippy::inherent_to_string_shadow_display)]
- pub fn to_string(self) -> String {
- self.to_box().into_string()
- }
-}
-
-impl<Buf> Deref for YarnRef<'_, Buf>
-where
- Buf: crate::Buf + ?Sized,
-{
- type Target = Buf;
- fn deref(&self) -> &Buf {
- self.as_slice()
- }
-}
-
-impl<Buf> Copy for YarnRef<'_, Buf> where Buf: crate::Buf + ?Sized {}
-impl<Buf> Clone for YarnRef<'_, Buf>
-where
- Buf: crate::Buf + ?Sized,
-{
- fn clone(&self) -> Self {
- *self
- }
-}
-
-impl<Buf: crate::Buf + ?Sized> fmt::Debug for YarnRef<'_, Buf> {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "\"")?;
- for chunk in self.utf8_chunks() {
- match chunk {
- Ok(utf8) => write!(f, "{}", utf8.escape_debug())?,
- Err(bytes) => {
- for b in bytes {
- write!(f, "\\x{:02X}", b)?;
- }
- }
- }
- }
- write!(f, "\"")
- }
-}
-
-impl<Buf: crate::Buf + ?Sized> fmt::Display for YarnRef<'_, Buf> {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- for chunk in self.utf8_chunks() {
- match chunk {
- Ok(utf8) => f.write_str(utf8)?,
- Err(..) => f.write_char(char::REPLACEMENT_CHARACTER)?,
- }
- }
-
- Ok(())
- }
-}
-
-impl<Slice, Buf> PartialEq<Slice> for YarnRef<'_, Buf>
-where
- Buf: crate::Buf + ?Sized,
- Slice: AsRef<Buf> + ?Sized,
-{
- fn eq(&self, that: &Slice) -> bool {
- self.as_slice() == that.as_ref()
- }
-}
-
-impl<Buf: crate::Buf + Eq + ?Sized> Eq for YarnRef<'_, Buf> {}
-
-impl<Slice, Buf> PartialOrd<Slice> for YarnRef<'_, Buf>
-where
- Buf: crate::Buf + ?Sized,
- Slice: AsRef<Buf> + ?Sized,
-{
- fn partial_cmp(&self, that: &Slice) -> Option<Ordering> {
- self.as_slice().partial_cmp(that.as_ref())
- }
-}
-
-impl<Buf: crate::Buf + ?Sized> Ord for YarnRef<'_, Buf> {
- fn cmp(&self, that: &Self) -> Ordering {
- self.as_slice().cmp(that.as_slice())
- }
-}
-
-impl<Buf: crate::Buf + ?Sized> Hash for YarnRef<'_, Buf> {
- fn hash<H: Hasher>(&self, state: &mut H) {
- self.as_slice().hash(state)
- }
-}
-
-impl<Buf: crate::Buf + ?Sized> Default for YarnRef<'_, Buf> {
- fn default() -> Self {
- *<&Self>::default()
- }
-}
-
-impl<Buf: crate::Buf + ?Sized> Default for &YarnRef<'_, Buf> {
- fn default() -> Self {
- YarnRef::empty()
- }
-}
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-29 00:33:24 +0000