diff options
Diffstat (limited to 'third_party/rust/unix_str/src/lib.rs')
| -rw-r--r-- | third_party/rust/unix_str/src/lib.rs | 1385 |
1 files changed, 1385 insertions, 0 deletions
diff --git a/third_party/rust/unix_str/src/lib.rs b/third_party/rust/unix_str/src/lib.rs new file mode 100644 index 0000000000..bf669233c5 --- /dev/null +++ b/third_party/rust/unix_str/src/lib.rs @@ -0,0 +1,1385 @@ +//! Strings that are compatible wuth Unix-like operating systems. +//! +//! * [`UnixString`] and [`UnixStr`] are useful when you need to with Unix strings. +//! Conversions between [`UnixString`], [`UnixStr`] and Rust strings work similarly +//! to those for `CString` and `CStr`. +//! +//! * [`UnixString`] represents an owned string in Unix's preferred +//! representation. +//! +//! * [`UnixStr`] represents a borrowed reference to a string in a format that +//! can be passed to a Unix-lie operating system. It can be converted into +//! a UTF-8 Rust string slice in a similar way to [`UnixString`]. +//! +//! # Conversions +//! +//! [`UnixStr`] implements two methods, [`from_bytes`] and [`as_bytes`]. +//! These do inexpensive conversions from and to UTF-8 byte slices. +//! +//! Additionally, [`UnixString`] provides [`from_vec`] and [`into_vec`] methods +//! that consume their arguments, and take or produce vectors of [`u8`]. +//! +//! [`UnixString`]: struct.UnixString.html +//! [`UnixStr`]: struct.UnixStr.html +//! [`from_vec`]: struct.UnixString.html#method.from_vec +//! [`into_vec`]: struct.UnixString.html#method.into_vec +//! [`from_bytes`]: struct.UnixStrExt.html#method.from_bytes +//! [`as_bytes`]: struct.UnixStrExt.html#method.as_bytes + +#![cfg_attr(feature = "shrink_to", feature(shrink_to))] +#![cfg_attr(feature = "toowned_clone_into", feature(toowned_clone_into))] +#![no_std] + +#[cfg(feature = "alloc")] +extern crate alloc; + +use core::cmp; +use core::fmt; +use core::hash::{Hash, Hasher}; +use core::mem; + +#[cfg(feature = "alloc")] +use alloc::borrow::{Borrow, Cow, ToOwned}; +#[cfg(feature = "alloc")] +use alloc::boxed::Box; +#[cfg(feature = "alloc")] +use alloc::rc::Rc; +#[cfg(feature = "alloc")] +use alloc::string::String; +#[cfg(feature = "alloc")] +use alloc::sync::Arc; +#[cfg(feature = "alloc")] +use alloc::vec::Vec; +#[cfg(feature = "alloc")] +use core::ops; +#[cfg(feature = "alloc")] +use core::str::FromStr; + +mod lossy; + +mod sys; +#[cfg(feature = "alloc")] +use sys::Buf; +use sys::Slice; + +mod sys_common; +use sys_common::AsInner; +#[cfg(feature = "alloc")] +use sys_common::{FromInner, IntoInner}; + +/// A type that can represent owned, mutable Unix strings, but is cheaply +/// inter-convertible with Rust strings. +/// +/// The need for this type arises from the fact that: +/// +/// * On Unix systems, strings are often arbitrary sequences of non-zero +/// bytes, in many cases interpreted as UTF-8. +/// +/// * In Rust, strings are always valid UTF-8, which may contain zeros. +/// +/// `UnixString` and [`UnixStr`] bridge this gap by simultaneously representing +/// Rust and platform-native string values, and in particular allowing a Rust +/// string to be converted into a “Unix” string with no cost if possible. +/// A consequence of this is that `UnixString` instances are *not* `NULL` +/// terminated; in order to pass to e.g., Unix system call, you should create +/// a `CStr`. +/// +/// `UnixString` is to [`&UnixStr`] as `String` is to `&str`: the former +/// in each pair are owned strings; the latter are borrowed references. +/// +/// Note, `UnixString` and [`UnixStr`] internally do not hold in the form native +/// to the platform: `UnixString`s are stored as a sequence of 8-bit values. +/// +/// # Creating an `UnixString` +/// +/// **From a Rust string**: `UnixString` implements `From<String>`, so you can +/// use `my_string.from` to create an `UnixString` from a normal Rust string. +/// +/// **From slices:** Just like you can start with an empty Rust [`String`] +/// and then [`push_str`][String.push_str] `&str` sub-string slices into it, +/// you can create an empty `UnixString` with the [`new`] method and then push +/// string slices into it with the [`push`] method. +/// +/// # Extracting a borrowed reference to the whole OS string +/// +/// You can use the [`as_unix_str`] method to get a [`&UnixStr`] from +/// a `UnixString`; this is effectively a borrowed reference to the whole +/// string. +/// +/// # Conversions +/// +/// See the [module's toplevel documentation about conversions][conversions] +/// for a discussion on the traits which `UnixString` implements for +/// [conversions] from/to native representations. +/// +/// [`UnixStr`]: struct.UnixStr.html +/// [`&UnixStr`]: struct.UnixStr.html +/// [`CStr`]: struct.CStr.html +/// [`new`]: #method.new +/// [`push`]: #method.push +/// [`as_unix_str`]: #method.as_unix_str +/// [conversions]: index.html#conversions +#[derive(Clone)] +#[cfg(feature = "alloc")] +pub struct UnixString { + inner: Buf, +} + +/// Borrowed reference to a Unix string (see [`UnixString`]). +/// +/// This type represents a borrowed reference to a string in Unix's preferred +/// representation. +/// +/// `&UnixStr` is to [`UnixString`] as `&str` is to `String`: the former +/// in each pair are borrowed references; the latter are owned strings. +/// +/// See the [module's toplevel documentation about conversions][conversions] +/// for a discussion on the traits which `UnixStr` implements for [conversions] +/// from/to native representations. +/// +/// [`UnixString`]: struct.UnixString.html +/// [conversions]: index.html#conversions +// FIXME: +// `UnixStr::from_inner` current implementation relies on `UnixStr` being +// layout-compatible with `Slice`. When attribute privacy is implemented, +// `UnixStr` should be annotated as `#[repr(transparent)]`. Anyway, `UnixStr` +// representation and layout are considered implementation detail, are +// not documented and must not be relied upon. +pub struct UnixStr { + inner: Slice, +} + +#[cfg(feature = "alloc")] +impl UnixString { + /// Constructs a new empty `UnixString`. + /// + /// # Examples + /// + /// ``` + /// use unix_str::UnixString; + /// + /// let unix_string = UnixString::new(); + /// ``` + pub fn new() -> Self { + Self { + inner: Buf::from_string(String::new()), + } + } + + /// Converts to an [`UnixStr`] slice. + /// + /// [`UnixStr`]: struct.UnixStr.html + /// + /// # Examples + /// + /// ``` + /// use unix_str::{UnixString, UnixStr}; + /// + /// let unix_string = UnixString::from("foo"); + /// let unix_str = UnixStr::new("foo"); + /// assert_eq!(unix_string.as_unix_str(), unix_str); + /// ``` + pub fn as_unix_str(&self) -> &UnixStr { + self + } + + /// Converts the `UnixString` into a `String` if it contains valid Unicode data. + /// + /// On failure, ownership of the original `UnixString` is returned. + /// + /// # Examples + /// + /// ``` + /// use unix_str::UnixString; + /// + /// let unix_string = UnixString::from("foo"); + /// let string = unix_string.into_string(); + /// assert_eq!(string, Ok(String::from("foo"))); + /// ``` + pub fn into_string(self) -> Result<String, UnixString> { + self.inner + .into_string() + .map_err(|buf| UnixString { inner: buf }) + } + + /// Extends the string with the given [`&UnixStr`] slice. + /// + /// [`&UnixStr`]: struct.UnixStr.html + /// + /// # Examples + /// + /// ``` + /// use unix_str::UnixString; + /// + /// let mut unix_string = UnixString::from("foo"); + /// unix_string.push("bar"); + /// assert_eq!(&unix_string, "foobar"); + /// ``` + pub fn push<T: AsRef<UnixStr>>(&mut self, s: T) { + self.inner.push_slice(&s.as_ref().inner) + } + + /// Creates a new `UnixString` with the given capacity. + /// + /// The string will be able to hold exactly `capacity` length units of other + /// OS strings without reallocating. If `capacity` is 0, the string will not + /// allocate. + /// + /// See main `UnixString` documentation information about encoding. + /// + /// # Examples + /// + /// ``` + /// use unix_str::UnixString; + /// + /// let mut unix_string = UnixString::with_capacity(10); + /// let capacity = unix_string.capacity(); + /// + /// // This push is done without reallocating + /// unix_string.push("foo"); + /// + /// assert_eq!(capacity, unix_string.capacity()); + /// ``` + pub fn with_capacity(capacity: usize) -> Self { + Self { + inner: Buf::with_capacity(capacity), + } + } + + /// Truncates the `UnixString` to zero length. + /// + /// # Examples + /// + /// ``` + /// use unix_str::UnixString; + /// + /// let mut unix_string = UnixString::from("foo"); + /// assert_eq!(&unix_string, "foo"); + /// + /// unix_string.clear(); + /// assert_eq!(&unix_string, ""); + /// ``` + pub fn clear(&mut self) { + self.inner.clear() + } + + /// Returns the capacity this `UnixString` can hold without reallocating. + /// + /// See `UnixString` introduction for information about encoding. + /// + /// # Examples + /// + /// ``` + /// use unix_str::UnixString; + /// + /// let unix_string = UnixString::with_capacity(10); + /// assert!(unix_string.capacity() >= 10); + /// ``` + pub fn capacity(&self) -> usize { + self.inner.capacity() + } + + /// Reserves capacity for at least `additional` more capacity to be inserted + /// in the given `UnixString`. + /// + /// The collection may reserve more space to avoid frequent reallocations. + /// + /// # Examples + /// + /// ``` + /// use unix_str::UnixString; + /// + /// let mut s = UnixString::new(); + /// s.reserve(10); + /// assert!(s.capacity() >= 10); + /// ``` + pub fn reserve(&mut self, additional: usize) { + self.inner.reserve(additional) + } + + /// Reserves the minimum capacity for exactly `additional` more capacity to + /// be inserted in the given `UnixString`. Does nothing if the capacity is + /// already sufficient. + /// + /// Note that the allocator may give the collection more space than it + /// requests. Therefore, capacity can not be relied upon to be precisely + /// minimal. Prefer reserve if future insertions are expected. + /// + /// # Examples + /// + /// ``` + /// use unix_str::UnixString; + /// + /// let mut s = UnixString::new(); + /// s.reserve_exact(10); + /// assert!(s.capacity() >= 10); + /// ``` + pub fn reserve_exact(&mut self, additional: usize) { + self.inner.reserve_exact(additional) + } + + /// Shrinks the capacity of the `UnixString` to match its length. + /// + /// # Examples + /// + /// ``` + /// use unix_str::UnixString; + /// + /// let mut s = UnixString::from("foo"); + /// + /// s.reserve(100); + /// assert!(s.capacity() >= 100); + /// + /// s.shrink_to_fit(); + /// assert_eq!(3, s.capacity()); + /// ``` + pub fn shrink_to_fit(&mut self) { + self.inner.shrink_to_fit() + } + + /// Shrinks the capacity of the `UnixString` with a lower bound. + /// + /// The capacity will remain at least as large as both the length + /// and the supplied value. + /// + /// Panics if the current capacity is smaller than the supplied + /// minimum capacity. + /// + /// # Examples + /// + /// ``` + /// #![feature(shrink_to)] + /// use std::ffi::UnixString; + /// + /// let mut s = UnixString::from("foo"); + /// + /// s.reserve(100); + /// assert!(s.capacity() >= 100); + /// + /// s.shrink_to(10); + /// assert!(s.capacity() >= 10); + /// s.shrink_to(0); + /// assert!(s.capacity() >= 3); + /// ``` + #[inline] + #[cfg(feature = "shrink_to")] + pub fn shrink_to(&mut self, min_capacity: usize) { + self.inner.shrink_to(min_capacity) + } + + /// Converts this `UnixString` into a boxed [`UnixStr`]. + /// + /// [`UnixStr`]: struct.UnixStr.html + /// + /// # Examples + /// + /// ``` + /// use unix_str::{UnixString, UnixStr}; + /// + /// let s = UnixString::from("hello"); + /// + /// let b: Box<UnixStr> = s.into_boxed_unix_str(); + /// ``` + pub fn into_boxed_unix_str(self) -> Box<UnixStr> { + let rw = Box::into_raw(self.inner.into_box()) as *mut UnixStr; + unsafe { Box::from_raw(rw) } + } + + /// Creates a `UnixString` from a byte vector. + /// + /// See the module documentation for an example. + /// + pub fn from_vec(vec: Vec<u8>) -> Self { + FromInner::from_inner(Buf { inner: vec }) + } + + /// Yields the underlying byte vector of this `UnixString`. + /// + /// See the module documentation for an example. + pub fn into_vec(self) -> Vec<u8> { + self.into_inner().inner + } +} + +#[cfg(feature = "alloc")] +impl From<String> for UnixString { + /// Converts a `String` into a [`UnixString`]. + /// + /// The conversion copies the data, and includes an allocation on the heap. + /// + /// [`UnixString`]: ../../std/ffi/struct.UnixString.html + fn from(s: String) -> Self { + UnixString { + inner: Buf::from_string(s), + } + } +} + +#[cfg(feature = "alloc")] +impl<T: ?Sized + AsRef<UnixStr>> From<&T> for UnixString { + fn from(s: &T) -> Self { + s.as_ref().to_unix_string() + } +} + +#[cfg(feature = "alloc")] +impl ops::Index<ops::RangeFull> for UnixString { + type Output = UnixStr; + + #[inline] + fn index(&self, _index: ops::RangeFull) -> &UnixStr { + UnixStr::from_inner(self.inner.as_slice()) + } +} + +#[cfg(feature = "alloc")] +impl ops::IndexMut<ops::RangeFull> for UnixString { + #[inline] + fn index_mut(&mut self, _index: ops::RangeFull) -> &mut UnixStr { + UnixStr::from_inner_mut(self.inner.as_mut_slice()) + } +} + +#[cfg(feature = "alloc")] +impl ops::Deref for UnixString { + type Target = UnixStr; + + #[inline] + fn deref(&self) -> &UnixStr { + &self[..] + } +} + +#[cfg(feature = "alloc")] +impl ops::DerefMut for UnixString { + #[inline] + fn deref_mut(&mut self) -> &mut UnixStr { + &mut self[..] + } +} + +#[cfg(feature = "alloc")] +impl Default for UnixString { + /// Constructs an empty `UnixString`. + #[inline] + fn default() -> Self { + Self::new() + } +} + +#[cfg(feature = "alloc")] +impl fmt::Debug for UnixString { + fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Debug::fmt(&**self, formatter) + } +} + +#[cfg(feature = "alloc")] +impl PartialEq for UnixString { + fn eq(&self, other: &Self) -> bool { + &**self == &**other + } +} + +#[cfg(feature = "alloc")] +impl PartialEq<str> for UnixString { + fn eq(&self, other: &str) -> bool { + &**self == other + } +} + +#[cfg(feature = "alloc")] +impl PartialEq<UnixString> for str { + fn eq(&self, other: &UnixString) -> bool { + &**other == self + } +} + +#[cfg(feature = "alloc")] +impl PartialEq<&str> for UnixString { + fn eq(&self, other: &&str) -> bool { + **self == **other + } +} + +#[cfg(feature = "alloc")] +impl<'a> PartialEq<UnixString> for &'a str { + fn eq(&self, other: &UnixString) -> bool { + **other == **self + } +} + +#[cfg(feature = "alloc")] +impl Eq for UnixString {} + +#[cfg(feature = "alloc")] +impl PartialOrd for UnixString { + #[inline] + fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> { + (&**self).partial_cmp(&**other) + } + #[inline] + fn lt(&self, other: &Self) -> bool { + &**self < &**other + } + #[inline] + fn le(&self, other: &Self) -> bool { + &**self <= &**other + } + #[inline] + fn gt(&self, other: &Self) -> bool { + &**self > &**other + } + #[inline] + fn ge(&self, other: &Self) -> bool { + &**self >= &**other + } +} + +#[cfg(feature = "alloc")] +impl PartialOrd<str> for UnixString { + #[inline] + fn partial_cmp(&self, other: &str) -> Option<cmp::Ordering> { + (&**self).partial_cmp(other) + } +} + +#[cfg(feature = "alloc")] +impl Ord for UnixString { + #[inline] + fn cmp(&self, other: &Self) -> cmp::Ordering { + (&**self).cmp(&**other) + } +} + +#[cfg(feature = "alloc")] +impl Hash for UnixString { + #[inline] + fn hash<H: Hasher>(&self, state: &mut H) { + (&**self).hash(state) + } +} + +impl UnixStr { + /// Coerces into an `UnixStr` slice. + /// + /// # Examples + /// + /// ``` + /// use unix_str::UnixStr; + /// + /// let unix_str = UnixStr::new("foo"); + /// ``` + #[inline] + pub fn new<S: AsRef<UnixStr> + ?Sized>(s: &S) -> &UnixStr { + s.as_ref() + } + + #[inline] + fn from_inner(inner: &Slice) -> &UnixStr { + // Safety: UnixStr is just a wrapper of Slice, + // therefore converting &Slice to &UnixStr is safe. + unsafe { &*(inner as *const Slice as *const UnixStr) } + } + + #[inline] + #[cfg(feature = "alloc")] + fn from_inner_mut(inner: &mut Slice) -> &mut UnixStr { + // Safety: UnixStr is just a wrapper of Slice, + // therefore converting &mut Slice to &mut UnixStr is safe. + // Any method that mutates UnixStr must be careful not to + // break platform-specific encoding, in particular Wtf8 on Windows. + unsafe { &mut *(inner as *mut Slice as *mut UnixStr) } + } + + /// Yields a `&str` slice if the `UnixStr` is valid Unicode. + /// + /// This conversion may entail doing a check for UTF-8 validity. + /// + /// # Examples + /// + /// ``` + /// use unix_str::UnixStr; + /// + /// let unix_str = UnixStr::new("foo"); + /// assert_eq!(unix_str.to_str(), Some("foo")); + /// ``` + pub fn to_str(&self) -> Option<&str> { + self.inner.to_str() + } + + /// Converts an `UnixStr` to a `Cow<str>`. + /// + /// Any non-Unicode sequences are replaced with + /// `U+FFFD REPLACEMENT CHARACTER`. + /// + /// + /// # Examples + /// + /// Calling `to_string_lossy` on an `UnixStr` with invalid unicode: + /// + /// ``` + /// use unix_str::UnixStr; + /// + /// // Here, the values 0x66 and 0x6f correspond to 'f' and 'o' + /// // respectively. The value 0x80 is a lone continuation byte, invalid + /// // in a UTF-8 sequence. + /// let source = [0x66, 0x6f, 0x80, 0x6f]; + /// let unix_str = UnixStr::from_bytes(&source[..]); + /// + /// assert_eq!(unix_str.to_string_lossy(), "fo�o"); + /// ``` + #[cfg(feature = "alloc")] + pub fn to_string_lossy(&self) -> Cow<'_, str> { + self.inner.to_string_lossy() + } + + /// Copies the slice into an owned [`UnixString`]. + /// + /// [`UnixString`]: struct.UnixString.html + /// + /// # Examples + /// + /// ``` + /// use unix_str::{UnixStr, UnixString}; + /// + /// let unix_str = UnixStr::new("foo"); + /// let unix_string = unix_str.to_unix_string(); + /// assert_eq!(unix_string, UnixString::from("foo")); + /// ``` + #[cfg(feature = "alloc")] + pub fn to_unix_string(&self) -> UnixString { + UnixString { + inner: self.inner.to_owned(), + } + } + + /// Checks whether the `UnixStr` is empty. + /// + /// # Examples + /// + /// ``` + /// use unix_str::UnixStr; + /// + /// let unix_str = UnixStr::new(""); + /// assert!(unix_str.is_empty()); + /// + /// let unix_str = UnixStr::new("foo"); + /// assert!(!unix_str.is_empty()); + /// ``` + #[inline] + pub fn is_empty(&self) -> bool { + self.inner.inner.is_empty() + } + + /// Returns the length of this `UnixStr`. + /// + /// Note that this does **not** return the number of bytes in the string in + /// OS string form. + /// + /// The length returned is that of the underlying storage used by `UnixStr`. + /// As discussed in the [`UnixString`] introduction, [`UnixString`] and + /// `UnixStr` store strings in a form best suited for cheap inter-conversion + /// between native-platform and Rust string forms, which may differ + /// significantly from both of them, including in storage size and encoding. + /// + /// This number is simply useful for passing to other methods, like + /// [`UnixString::with_capacity`] to avoid reallocations. + /// + /// [`UnixString`]: struct.UnixString.html + /// [`UnixString::with_capacity`]: struct.UnixString.html#method.with_capacity + /// + /// # Examples + /// + /// ``` + /// use unix_str::UnixStr; + /// + /// let unix_str = UnixStr::new(""); + /// assert_eq!(unix_str.len(), 0); + /// + /// let unix_str = UnixStr::new("foo"); + /// assert_eq!(unix_str.len(), 3); + /// ``` + pub fn len(&self) -> usize { + self.inner.inner.len() + } + + /// Converts a `Box<UnixStr>` into an [`UnixString`] without copying + /// allocating. + /// + /// [`UnixString`]: struct.UnixString.html + #[cfg(feature = "alloc")] + pub fn into_unix_string(self: Box<UnixStr>) -> UnixString { + let boxed = unsafe { Box::from_raw(Box::into_raw(self) as *mut Slice) }; + UnixString { + inner: Buf::from_box(boxed), + } + } + + /// Gets the underlying byte representation. + /// + /// Note: it is *crucial* that this API is private, to avoid + /// revealing the internal, platform-specific encodings. + #[inline] + fn bytes(&self) -> &[u8] { + unsafe { &*(&self.inner as *const _ as *const [u8]) } + } + + /// Converts this string to its ASCII lower case equivalent in-place. + /// + /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z', but non-ASCII letters + /// are unchanged. + /// + /// To return a new lowercased value without modifying the existing one, use + /// [`to_ascii_lowercase`]. + /// + /// [`to_ascii_lowercase`]: #method.to_ascii_lowercase + /// + /// # Examples + /// + /// ``` + /// use unix_str::UnixString; + /// + /// let mut s = UnixString::from("GRÜßE, JÜRGEN ❤"); + /// + /// s.make_ascii_lowercase(); + /// + /// assert_eq!("grÜße, jÜrgen ❤", s); + /// ``` + #[cfg(feature = "unixstring_ascii")] + pub fn make_ascii_lowercase(&mut self) { + self.inner.make_ascii_lowercase() + } + + /// Converts this string to its ASCII upper case equivalent in-place. + /// + /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z', + /// but non-ASCII letters are unchanged. + /// + /// To return a new uppercased value without modifying the existing one, use + /// [`to_ascii_uppercase`]. + /// + /// [`to_ascii_uppercase`]: #method.to_ascii_uppercase + /// + /// # Examples + /// + /// ``` + /// use unix_str::UnixString; + /// + /// let mut s = UnixString::from("Grüße, Jürgen ❤"); + /// + /// s.make_ascii_uppercase(); + /// + /// assert_eq!("GRüßE, JüRGEN ❤", s); + /// ``` + #[cfg(feature = "unixstring_ascii")] + pub fn make_ascii_uppercase(&mut self) { + self.inner.make_ascii_uppercase() + } + + /// Returns a copy of this string where each character is mapped to its + /// ASCII lower case equivalent. + /// + /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z', + /// but non-ASCII letters are unchanged. + /// + /// To lowercase the value in-place, use [`make_ascii_lowercase`]. + /// + /// [`make_ascii_lowercase`]: #method.make_ascii_lowercase + /// + /// # Examples + /// + /// ``` + /// use unix_str::UnixString; + /// let s = UnixString::from("Grüße, Jürgen ❤"); + /// + /// assert_eq!("grüße, jürgen ❤", s.to_ascii_lowercase()); + /// ``` + #[cfg(all(feature = "alloc", feature = "unixstring_ascii"))] + pub fn to_ascii_lowercase(&self) -> UnixString { + UnixString::from_inner(self.inner.to_ascii_lowercase()) + } + + /// Returns a copy of this string where each character is mapped to its + /// ASCII upper case equivalent. + /// + /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z', + /// but non-ASCII letters are unchanged. + /// + /// To uppercase the value in-place, use [`make_ascii_uppercase`]. + /// + /// [`make_ascii_uppercase`]: #method.make_ascii_uppercase + /// + /// # Examples + /// + /// ``` + /// use unix_str::UnixString; + /// let s = UnixString::from("Grüße, Jürgen ❤"); + /// + /// assert_eq!("GRüßE, JüRGEN ❤", s.to_ascii_uppercase()); + /// ``` + #[cfg(all(feature = "alloc", feature = "unixstring_ascii"))] + pub fn to_ascii_uppercase(&self) -> UnixString { + UnixString::from_inner(self.inner.to_ascii_uppercase()) + } + + /// Checks if all characters in this string are within the ASCII range. + /// + /// # Examples + /// + /// ``` + /// use unix_str::UnixString; + /// + /// let ascii = UnixString::from("hello!\n"); + /// let non_ascii = UnixString::from("Grüße, Jürgen ❤"); + /// + /// assert!(ascii.is_ascii()); + /// assert!(!non_ascii.is_ascii()); + /// ``` + #[cfg(feature = "unixstring_ascii")] + pub fn is_ascii(&self) -> bool { + self.inner.is_ascii() + } + + /// Checks that two strings are an ASCII case-insensitive match. + /// + /// Same as `to_ascii_lowercase(a) == to_ascii_lowercase(b)`, + /// but without allocating and copying temporaries. + /// + /// # Examples + /// + /// ``` + /// use unix_str::UnixString; + /// + /// assert!(UnixString::from("Ferris").eq_ignore_ascii_case("FERRIS")); + /// assert!(UnixString::from("Ferrös").eq_ignore_ascii_case("FERRöS")); + /// assert!(!UnixString::from("Ferrös").eq_ignore_ascii_case("FERRÖS")); + /// ``` + #[cfg(feature = "unixstring_ascii")] + pub fn eq_ignore_ascii_case<S: ?Sized + AsRef<UnixStr>>(&self, other: &S) -> bool { + self.inner.eq_ignore_ascii_case(&other.as_ref().inner) + } + + /// Creates a `UnixStr` from a byte slice. + /// + /// See the module documentation for an example. + pub fn from_bytes(slice: &[u8]) -> &Self { + unsafe { mem::transmute(slice) } + } + + /// Gets the underlying byte view of the `UnixStr` slice. + /// + /// See the module documentation for an example. + pub fn as_bytes(&self) -> &[u8] { + &self.as_inner().inner + } +} + +#[cfg(feature = "alloc")] +impl From<&UnixStr> for Box<UnixStr> { + fn from(s: &UnixStr) -> Self { + let rw = Box::into_raw(s.inner.into_box()) as *mut UnixStr; + unsafe { Box::from_raw(rw) } + } +} + +#[cfg(feature = "alloc")] +impl From<Cow<'_, UnixStr>> for Box<UnixStr> { + #[inline] + fn from(cow: Cow<'_, UnixStr>) -> Self { + match cow { + Cow::Borrowed(s) => Box::from(s), + Cow::Owned(s) => Box::from(s), + } + } +} + +#[cfg(feature = "alloc")] +impl From<Box<UnixStr>> for UnixString { + /// Converts a `Box<UnixStr>` into a `UnixString` without copying or + /// allocating. + /// + /// [`UnixStr`]: ../ffi/struct.UnixStr.html + fn from(boxed: Box<UnixStr>) -> Self { + boxed.into_unix_string() + } +} + +#[cfg(feature = "alloc")] +impl From<UnixString> for Box<UnixStr> { + /// Converts a [`UnixString`] into a `Box<UnixStr>` without copying or + /// allocating. + /// + /// [`UnixString`]: ../ffi/struct.UnixString.html + fn from(s: UnixString) -> Self { + s.into_boxed_unix_str() + } +} + +#[cfg(feature = "alloc")] +impl Clone for Box<UnixStr> { + #[inline] + fn clone(&self) -> Self { + self.to_unix_string().into_boxed_unix_str() + } +} + +#[cfg(feature = "alloc")] +impl From<UnixString> for Arc<UnixStr> { + /// Converts a [`UnixString`] into a `Arc<UnixStr>` without copying or + /// allocating. + /// + /// [`UnixString`]: ../ffi/struct.UnixString.html + #[inline] + fn from(s: UnixString) -> Self { + let arc = s.inner.into_arc(); + unsafe { Arc::from_raw(Arc::into_raw(arc) as *const UnixStr) } + } +} + +#[cfg(feature = "alloc")] +impl From<&UnixStr> for Arc<UnixStr> { + #[inline] + fn from(s: &UnixStr) -> Self { + let arc = s.inner.into_arc(); + unsafe { Arc::from_raw(Arc::into_raw(arc) as *const UnixStr) } + } +} + +#[cfg(feature = "alloc")] +impl From<UnixString> for Rc<UnixStr> { + /// Converts a [`UnixString`] into a `Rc<UnixStr>` without copying or + /// allocating. + /// + /// [`UnixString`]: ../ffi/struct.UnixString.html + #[inline] + fn from(s: UnixString) -> Self { + let rc = s.inner.into_rc(); + unsafe { Rc::from_raw(Rc::into_raw(rc) as *const UnixStr) } + } +} + +#[cfg(feature = "alloc")] +impl From<&UnixStr> for Rc<UnixStr> { + #[inline] + fn from(s: &UnixStr) -> Self { + let rc = s.inner.into_rc(); + unsafe { Rc::from_raw(Rc::into_raw(rc) as *const UnixStr) } + } +} + +#[cfg(feature = "alloc")] +impl<'a> From<UnixString> for Cow<'a, UnixStr> { + #[inline] + fn from(s: UnixString) -> Self { + Cow::Owned(s) + } +} + +#[cfg(feature = "alloc")] +impl<'a> From<&'a UnixStr> for Cow<'a, UnixStr> { + #[inline] + fn from(s: &'a UnixStr) -> Self { + Cow::Borrowed(s) + } +} + +#[cfg(feature = "alloc")] +impl<'a> From<&'a UnixString> for Cow<'a, UnixStr> { + #[inline] + fn from(s: &'a UnixString) -> Self { + Cow::Borrowed(s.as_unix_str()) + } +} + +#[cfg(feature = "alloc")] +impl<'a> From<Cow<'a, UnixStr>> for UnixString { + #[inline] + fn from(s: Cow<'a, UnixStr>) -> Self { + s.into_owned() + } +} + +#[cfg(feature = "alloc")] +impl Default for Box<UnixStr> { + fn default() -> Self { + let rw = Box::into_raw(Slice::empty_box()) as *mut UnixStr; + unsafe { Box::from_raw(rw) } + } +} + +impl Default for &UnixStr { + /// Creates an empty `UnixStr`. + #[inline] + fn default() -> Self { + UnixStr::new("") + } +} + +impl PartialEq for UnixStr { + #[inline] + fn eq(&self, other: &UnixStr) -> bool { + self.bytes().eq(other.bytes()) + } +} + +impl PartialEq<str> for UnixStr { + #[inline] + fn eq(&self, other: &str) -> bool { + *self == *UnixStr::new(other) + } +} + +impl PartialEq<UnixStr> for str { + #[inline] + fn eq(&self, other: &UnixStr) -> bool { + *other == *UnixStr::new(self) + } +} + +impl Eq for UnixStr {} + +impl PartialOrd for UnixStr { + #[inline] + fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> { + self.bytes().partial_cmp(other.bytes()) + } + #[inline] + fn lt(&self, other: &Self) -> bool { + self.bytes().lt(other.bytes()) + } + #[inline] + fn le(&self, other: &Self) -> bool { + self.bytes().le(other.bytes()) + } + #[inline] + fn gt(&self, other: &Self) -> bool { + self.bytes().gt(other.bytes()) + } + #[inline] + fn ge(&self, other: &Self) -> bool { + self.bytes().ge(other.bytes()) + } +} + +impl PartialOrd<str> for UnixStr { + #[inline] + fn partial_cmp(&self, other: &str) -> Option<cmp::Ordering> { + self.partial_cmp(Self::new(other)) + } +} + +// FIXME (#19470): cannot provide PartialOrd<UnixStr> for str until we +// have more flexible coherence rules. + +impl Ord for UnixStr { + #[inline] + fn cmp(&self, other: &Self) -> cmp::Ordering { + self.bytes().cmp(other.bytes()) + } +} + +#[cfg(feature = "alloc")] +macro_rules! impl_cmp { + ($lhs:ty, $rhs: ty) => { + impl<'a, 'b> PartialEq<$rhs> for $lhs { + #[inline] + fn eq(&self, other: &$rhs) -> bool { + <UnixStr as PartialEq>::eq(self, other) + } + } + + impl<'a, 'b> PartialEq<$lhs> for $rhs { + #[inline] + fn eq(&self, other: &$lhs) -> bool { + <UnixStr as PartialEq>::eq(self, other) + } + } + + impl<'a, 'b> PartialOrd<$rhs> for $lhs { + #[inline] + fn partial_cmp(&self, other: &$rhs) -> Option<cmp::Ordering> { + <UnixStr as PartialOrd>::partial_cmp(self, other) + } + } + + impl<'a, 'b> PartialOrd<$lhs> for $rhs { + #[inline] + fn partial_cmp(&self, other: &$lhs) -> Option<cmp::Ordering> { + <UnixStr as PartialOrd>::partial_cmp(self, other) + } + } + }; +} + +#[cfg(feature = "alloc")] +impl_cmp!(UnixString, UnixStr); +#[cfg(feature = "alloc")] +impl_cmp!(UnixString, &'a UnixStr); +#[cfg(feature = "alloc")] +impl_cmp!(Cow<'a, UnixStr>, UnixStr); +#[cfg(feature = "alloc")] +impl_cmp!(Cow<'a, UnixStr>, &'b UnixStr); +#[cfg(feature = "alloc")] +impl_cmp!(Cow<'a, UnixStr>, UnixString); + +impl Hash for UnixStr { + #[inline] + fn hash<H: Hasher>(&self, state: &mut H) { + self.bytes().hash(state) + } +} + +impl fmt::Debug for UnixStr { + fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Debug::fmt(&self.inner, formatter) + } +} + +#[cfg(feature = "alloc")] +impl Borrow<UnixStr> for UnixString { + fn borrow(&self) -> &UnixStr { + &self[..] + } +} + +#[cfg(feature = "alloc")] +impl ToOwned for UnixStr { + type Owned = UnixString; + fn to_owned(&self) -> Self::Owned { + self.to_unix_string() + } + #[cfg(feature = "toowned_clone_into")] + fn clone_into(&self, target: &mut Self::Owned) { + self.inner.clone_into(&mut target.inner) + } +} + +impl AsRef<UnixStr> for UnixStr { + fn as_ref(&self) -> &UnixStr { + self + } +} + +#[cfg(feature = "alloc")] +impl AsRef<UnixStr> for UnixString { + #[inline] + fn as_ref(&self) -> &UnixStr { + self + } +} + +impl AsRef<UnixStr> for str { + #[inline] + fn as_ref(&self) -> &UnixStr { + UnixStr::from_inner(Slice::from_str(self)) + } +} + +#[cfg(feature = "alloc")] +impl AsRef<UnixStr> for String { + #[inline] + fn as_ref(&self) -> &UnixStr { + (&**self).as_ref() + } +} + +#[cfg(feature = "alloc")] +impl FromInner<Buf> for UnixString { + fn from_inner(buf: Buf) -> UnixString { + UnixString { inner: buf } + } +} + +#[cfg(feature = "alloc")] +impl IntoInner<Buf> for UnixString { + fn into_inner(self) -> Buf { + self.inner + } +} + +impl AsInner<Slice> for UnixStr { + #[inline] + fn as_inner(&self) -> &Slice { + &self.inner + } +} + +#[cfg(feature = "alloc")] +impl FromStr for UnixString { + type Err = core::convert::Infallible; + + fn from_str(s: &str) -> Result<Self, Self::Err> { + Ok(UnixString::from(s)) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use sys_common::{AsInner, IntoInner}; + + use alloc::rc::Rc; + use alloc::sync::Arc; + + #[test] + fn test_unix_string_with_capacity() { + let unix_string = UnixString::with_capacity(0); + assert_eq!(0, unix_string.inner.into_inner().capacity()); + + let unix_string = UnixString::with_capacity(10); + assert_eq!(10, unix_string.inner.into_inner().capacity()); + + let mut unix_string = UnixString::with_capacity(0); + unix_string.push("abc"); + assert!(unix_string.inner.into_inner().capacity() >= 3); + } + + #[test] + fn test_unix_string_clear() { + let mut unix_string = UnixString::from("abc"); + assert_eq!(3, unix_string.inner.as_inner().len()); + + unix_string.clear(); + assert_eq!(&unix_string, ""); + assert_eq!(0, unix_string.inner.as_inner().len()); + } + + #[test] + fn test_unix_string_capacity() { + let unix_string = UnixString::with_capacity(0); + assert_eq!(0, unix_string.capacity()); + + let unix_string = UnixString::with_capacity(10); + assert_eq!(10, unix_string.capacity()); + + let mut unix_string = UnixString::with_capacity(0); + unix_string.push("abc"); + assert!(unix_string.capacity() >= 3); + } + + #[test] + fn test_unix_string_reserve() { + let mut unix_string = UnixString::new(); + assert_eq!(unix_string.capacity(), 0); + + unix_string.reserve(2); + assert!(unix_string.capacity() >= 2); + + for _ in 0..16 { + unix_string.push("a"); + } + + assert!(unix_string.capacity() >= 16); + unix_string.reserve(16); + assert!(unix_string.capacity() >= 32); + + unix_string.push("a"); + + unix_string.reserve(16); + assert!(unix_string.capacity() >= 33) + } + + #[test] + fn test_unix_string_reserve_exact() { + let mut unix_string = UnixString::new(); + assert_eq!(unix_string.capacity(), 0); + + unix_string.reserve_exact(2); + assert!(unix_string.capacity() >= 2); + + for _ in 0..16 { + unix_string.push("a"); + } + + assert!(unix_string.capacity() >= 16); + unix_string.reserve_exact(16); + assert!(unix_string.capacity() >= 32); + + unix_string.push("a"); + + unix_string.reserve_exact(16); + assert!(unix_string.capacity() >= 33) + } + + #[test] + fn test_unix_string_default() { + let unix_string: UnixString = Default::default(); + assert_eq!("", &unix_string); + } + + #[test] + fn test_unix_str_is_empty() { + let mut unix_string = UnixString::new(); + assert!(unix_string.is_empty()); + + unix_string.push("abc"); + assert!(!unix_string.is_empty()); + + unix_string.clear(); + assert!(unix_string.is_empty()); + } + + #[test] + fn test_unix_str_len() { + let mut unix_string = UnixString::new(); + assert_eq!(0, unix_string.len()); + + unix_string.push("abc"); + assert_eq!(3, unix_string.len()); + + unix_string.clear(); + assert_eq!(0, unix_string.len()); + } + + #[test] + fn test_unix_str_default() { + let unix_str: &UnixStr = Default::default(); + assert_eq!("", unix_str); + } + + #[test] + fn into_boxed() { + let orig = "Hello, world!"; + let unix_str = UnixStr::new(orig); + let boxed: Box<UnixStr> = Box::from(unix_str); + let unix_string = unix_str.to_owned().into_boxed_unix_str().into_unix_string(); + assert_eq!(unix_str, &*boxed); + assert_eq!(&*boxed, &*unix_string); + assert_eq!(&*unix_string, unix_str); + } + + #[test] + fn boxed_default() { + let boxed = <Box<UnixStr>>::default(); + assert!(boxed.is_empty()); + } + + #[test] + #[cfg(feature = "toowned_clone_into")] + fn test_unix_str_clone_into() { + let mut unix_string = UnixString::with_capacity(123); + unix_string.push("hello"); + let unix_str = UnixStr::new("bonjour"); + unix_str.clone_into(&mut unix_string); + assert_eq!(unix_str, unix_string); + assert!(unix_string.capacity() >= 123); + } + + #[test] + fn into_rc() { + let orig = "Hello, world!"; + let unix_str = UnixStr::new(orig); + let rc: Rc<UnixStr> = Rc::from(unix_str); + let arc: Arc<UnixStr> = Arc::from(unix_str); + + assert_eq!(&*rc, unix_str); + assert_eq!(&*arc, unix_str); + + let rc2: Rc<UnixStr> = Rc::from(unix_str.to_owned()); + let arc2: Arc<UnixStr> = Arc::from(unix_str.to_owned()); + + assert_eq!(&*rc2, unix_str); + assert_eq!(&*arc2, unix_str); + } +} |