summaryrefslogtreecommitdiff
path: root/vendor/tinystr/src
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/tinystr/src')
-rw-r--r--vendor/tinystr/src/ascii.rs1175
-rw-r--r--vendor/tinystr/src/asciibyte.rs145
-rw-r--r--vendor/tinystr/src/databake.rs75
-rw-r--r--vendor/tinystr/src/error.rs18
-rw-r--r--vendor/tinystr/src/int_ops.rs315
-rw-r--r--vendor/tinystr/src/lib.rs114
-rw-r--r--vendor/tinystr/src/macros.rs32
-rw-r--r--vendor/tinystr/src/serde.rs91
-rw-r--r--vendor/tinystr/src/ule.rs125
-rw-r--r--vendor/tinystr/src/unvalidated.rs122
10 files changed, 0 insertions, 2212 deletions
diff --git a/vendor/tinystr/src/ascii.rs b/vendor/tinystr/src/ascii.rs
deleted file mode 100644
index 89ec742b..00000000
--- a/vendor/tinystr/src/ascii.rs
+++ /dev/null
@@ -1,1175 +0,0 @@
-// This file is part of ICU4X. For terms of use, please see the file
-// called LICENSE at the top level of the ICU4X source tree
-// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
-
-use crate::asciibyte::AsciiByte;
-use crate::int_ops::{Aligned4, Aligned8};
-use crate::ParseError;
-use core::borrow::Borrow;
-use core::fmt;
-use core::ops::Deref;
-use core::str::{self, FromStr};
-
-#[repr(transparent)]
-#[derive(PartialEq, Eq, Ord, PartialOrd, Copy, Clone, Hash)]
-pub struct TinyAsciiStr<const N: usize> {
- bytes: [AsciiByte; N],
-}
-
-impl<const N: usize> TinyAsciiStr<N> {
- #[inline]
- pub const fn try_from_str(s: &str) -> Result<Self, ParseError> {
- Self::try_from_utf8(s.as_bytes())
- }
-
- /// Creates a `TinyAsciiStr<N>` from the given UTF-8 slice.
- /// `code_units` may contain at most `N` non-null ASCII code points.
- #[inline]
- pub const fn try_from_utf8(code_units: &[u8]) -> Result<Self, ParseError> {
- Self::try_from_utf8_inner(code_units, false)
- }
-
- /// Creates a `TinyAsciiStr<N>` from the given UTF-16 slice.
- /// `code_units` may contain at most `N` non-null ASCII code points.
- #[inline]
- pub const fn try_from_utf16(code_units: &[u16]) -> Result<Self, ParseError> {
- Self::try_from_utf16_inner(code_units, 0, code_units.len(), false)
- }
-
- /// Creates a `TinyAsciiStr<N>` from a UTF-8 slice, replacing invalid code units.
- ///
- /// Invalid code units, as well as null or non-ASCII code points
- /// (i.e. those outside the range U+0001..=U+007F`)
- /// will be replaced with the replacement byte.
- ///
- /// The input slice will be truncated if its length exceeds `N`.
- pub const fn from_utf8_lossy(code_units: &[u8], replacement: u8) -> Self {
- let mut out = [0; N];
- let mut i = 0;
- // Ord is not available in const, so no `.min(N)`
- let len = if code_units.len() > N {
- N
- } else {
- code_units.len()
- };
-
- // Indexing is protected by the len check above
- #[allow(clippy::indexing_slicing)]
- while i < len {
- let b = code_units[i];
- if b > 0 && b < 0x80 {
- out[i] = b;
- } else {
- out[i] = replacement;
- }
- i += 1;
- }
-
- Self {
- // SAFETY: `out` only contains ASCII bytes and has same size as `self.bytes`
- bytes: unsafe { AsciiByte::to_ascii_byte_array(&out) },
- }
- }
-
- /// Creates a `TinyAsciiStr<N>` from a UTF-16 slice, replacing invalid code units.
- ///
- /// Invalid code units, as well as null or non-ASCII code points
- /// (i.e. those outside the range U+0001..=U+007F`)
- /// will be replaced with the replacement byte.
- ///
- /// The input slice will be truncated if its length exceeds `N`.
- pub const fn from_utf16_lossy(code_units: &[u16], replacement: u8) -> Self {
- let mut out = [0; N];
- let mut i = 0;
- // Ord is not available in const, so no `.min(N)`
- let len = if code_units.len() > N {
- N
- } else {
- code_units.len()
- };
-
- // Indexing is protected by the len check above
- #[allow(clippy::indexing_slicing)]
- while i < len {
- let b = code_units[i];
- if b > 0 && b < 0x80 {
- out[i] = b as u8;
- } else {
- out[i] = replacement;
- }
- i += 1;
- }
-
- Self {
- // SAFETY: `out` only contains ASCII bytes and has same size as `self.bytes`
- bytes: unsafe { AsciiByte::to_ascii_byte_array(&out) },
- }
- }
-
- /// Attempts to parse a fixed-length byte array to a `TinyAsciiStr`.
- ///
- /// The byte array may contain trailing NUL bytes.
- ///
- /// # Example
- ///
- /// ```
- /// use tinystr::tinystr;
- /// use tinystr::TinyAsciiStr;
- ///
- /// assert_eq!(
- /// TinyAsciiStr::<3>::try_from_raw(*b"GB\0"),
- /// Ok(tinystr!(3, "GB"))
- /// );
- /// assert_eq!(
- /// TinyAsciiStr::<3>::try_from_raw(*b"USD"),
- /// Ok(tinystr!(3, "USD"))
- /// );
- /// assert!(matches!(TinyAsciiStr::<3>::try_from_raw(*b"\0A\0"), Err(_)));
- /// ```
- pub const fn try_from_raw(raw: [u8; N]) -> Result<Self, ParseError> {
- Self::try_from_utf8_inner(&raw, true)
- }
-
- pub(crate) const fn try_from_utf8_inner(
- code_units: &[u8],
- allow_trailing_null: bool,
- ) -> Result<Self, ParseError> {
- if code_units.len() > N {
- return Err(ParseError::TooLong {
- max: N,
- len: code_units.len(),
- });
- }
-
- let mut out = [0; N];
- let mut i = 0;
- let mut found_null = false;
- // Indexing is protected by TinyStrError::TooLarge
- #[allow(clippy::indexing_slicing)]
- while i < code_units.len() {
- let b = code_units[i];
-
- if b == 0 {
- found_null = true;
- } else if b >= 0x80 {
- return Err(ParseError::NonAscii);
- } else if found_null {
- // Error if there are contentful bytes after null
- return Err(ParseError::ContainsNull);
- }
- out[i] = b;
-
- i += 1;
- }
-
- if !allow_trailing_null && found_null {
- // We found some trailing nulls, error
- return Err(ParseError::ContainsNull);
- }
-
- Ok(Self {
- // SAFETY: `out` only contains ASCII bytes and has same size as `self.bytes`
- bytes: unsafe { AsciiByte::to_ascii_byte_array(&out) },
- })
- }
-
- pub(crate) const fn try_from_utf16_inner(
- code_units: &[u16],
- start: usize,
- end: usize,
- allow_trailing_null: bool,
- ) -> Result<Self, ParseError> {
- let len = end - start;
- if len > N {
- return Err(ParseError::TooLong { max: N, len });
- }
-
- let mut out = [0; N];
- let mut i = 0;
- let mut found_null = false;
- // Indexing is protected by TinyStrError::TooLarge
- #[allow(clippy::indexing_slicing)]
- while i < len {
- let b = code_units[start + i];
-
- if b == 0 {
- found_null = true;
- } else if b >= 0x80 {
- return Err(ParseError::NonAscii);
- } else if found_null {
- // Error if there are contentful bytes after null
- return Err(ParseError::ContainsNull);
- }
- out[i] = b as u8;
-
- i += 1;
- }
-
- if !allow_trailing_null && found_null {
- // We found some trailing nulls, error
- return Err(ParseError::ContainsNull);
- }
-
- Ok(Self {
- // SAFETY: `out` only contains ASCII bytes and has same size as `self.bytes`
- bytes: unsafe { AsciiByte::to_ascii_byte_array(&out) },
- })
- }
-
- #[inline]
- pub const fn as_str(&self) -> &str {
- // as_utf8 is valid utf8
- unsafe { str::from_utf8_unchecked(self.as_utf8()) }
- }
-
- #[inline]
- #[must_use]
- pub const fn len(&self) -> usize {
- if N <= 4 {
- Aligned4::from_ascii_bytes(&self.bytes).len()
- } else if N <= 8 {
- Aligned8::from_ascii_bytes(&self.bytes).len()
- } else {
- let mut i = 0;
- #[allow(clippy::indexing_slicing)] // < N is safe
- while i < N && self.bytes[i] as u8 != AsciiByte::B0 as u8 {
- i += 1
- }
- i
- }
- }
-
- #[inline]
- #[must_use]
- pub const fn is_empty(&self) -> bool {
- self.bytes[0] as u8 == AsciiByte::B0 as u8
- }
-
- #[inline]
- #[must_use]
- pub const fn as_utf8(&self) -> &[u8] {
- // Safe because `self.bytes.as_slice()` pointer-casts to `&[u8]`,
- // and changing the length of that slice to self.len() < N is safe.
- unsafe {
- core::slice::from_raw_parts(self.bytes.as_slice().as_ptr() as *const u8, self.len())
- }
- }
-
- #[inline]
- #[must_use]
- pub const fn all_bytes(&self) -> &[u8; N] {
- // SAFETY: `self.bytes` has same size as [u8; N]
- unsafe { &*(self.bytes.as_ptr() as *const [u8; N]) }
- }
-
- #[inline]
- #[must_use]
- /// Resizes a `TinyAsciiStr<N>` to a `TinyAsciiStr<M>`.
- ///
- /// If `M < len()` the string gets truncated, otherwise only the
- /// memory representation changes.
- pub const fn resize<const M: usize>(self) -> TinyAsciiStr<M> {
- let mut bytes = [0; M];
- let mut i = 0;
- // Indexing is protected by the loop guard
- #[allow(clippy::indexing_slicing)]
- while i < M && i < N {
- bytes[i] = self.bytes[i] as u8;
- i += 1;
- }
- // `self.bytes` only contains ASCII bytes, with no null bytes between
- // ASCII characters, so this also holds for `bytes`.
- unsafe { TinyAsciiStr::from_utf8_unchecked(bytes) }
- }
-
- #[inline]
- #[must_use]
- /// Returns a `TinyAsciiStr<Q>` with the concatenation of this string,
- /// `TinyAsciiStr<N>`, and another string, `TinyAsciiStr<M>`.
- ///
- /// If `Q < N + M`, the string gets truncated.
- ///
- /// # Examples
- ///
- /// ```
- /// use tinystr::tinystr;
- /// use tinystr::TinyAsciiStr;
- ///
- /// let abc = tinystr!(6, "abc");
- /// let defg = tinystr!(6, "defg");
- ///
- /// // The concatenation is successful if Q is large enough...
- /// assert_eq!(abc.concat(defg), tinystr!(16, "abcdefg"));
- /// assert_eq!(abc.concat(defg), tinystr!(12, "abcdefg"));
- /// assert_eq!(abc.concat(defg), tinystr!(8, "abcdefg"));
- /// assert_eq!(abc.concat(defg), tinystr!(7, "abcdefg"));
- ///
- /// /// ...but it truncates of Q is too small.
- /// assert_eq!(abc.concat(defg), tinystr!(6, "abcdef"));
- /// assert_eq!(abc.concat(defg), tinystr!(2, "ab"));
- /// ```
- pub const fn concat<const M: usize, const Q: usize>(
- self,
- other: TinyAsciiStr<M>,
- ) -> TinyAsciiStr<Q> {
- let mut result = self.resize::<Q>();
- let mut i = self.len();
- let mut j = 0;
- // Indexing is protected by the loop guard
- #[allow(clippy::indexing_slicing)]
- while i < Q && j < M {
- result.bytes[i] = other.bytes[j];
- i += 1;
- j += 1;
- }
- result
- }
-
- /// # Safety
- /// Must be called with a bytes array made of valid ASCII bytes, with no null bytes
- /// between ASCII characters
- #[must_use]
- pub const unsafe fn from_utf8_unchecked(code_units: [u8; N]) -> Self {
- Self {
- bytes: AsciiByte::to_ascii_byte_array(&code_units),
- }
- }
-}
-
-macro_rules! check_is {
- ($self:ident, $check_int:ident, $check_u8:ident) => {
- if N <= 4 {
- Aligned4::from_ascii_bytes(&$self.bytes).$check_int()
- } else if N <= 8 {
- Aligned8::from_ascii_bytes(&$self.bytes).$check_int()
- } else {
- let mut i = 0;
- // Won't panic because self.bytes has length N
- #[allow(clippy::indexing_slicing)]
- while i < N && $self.bytes[i] as u8 != AsciiByte::B0 as u8 {
- if !($self.bytes[i] as u8).$check_u8() {
- return false;
- }
- i += 1;
- }
- true
- }
- };
- ($self:ident, $check_int:ident, !$check_u8_0_inv:ident, !$check_u8_1_inv:ident) => {
- if N <= 4 {
- Aligned4::from_ascii_bytes(&$self.bytes).$check_int()
- } else if N <= 8 {
- Aligned8::from_ascii_bytes(&$self.bytes).$check_int()
- } else {
- // Won't panic because N is > 8
- if ($self.bytes[0] as u8).$check_u8_0_inv() {
- return false;
- }
- let mut i = 1;
- // Won't panic because self.bytes has length N
- #[allow(clippy::indexing_slicing)]
- while i < N && $self.bytes[i] as u8 != AsciiByte::B0 as u8 {
- if ($self.bytes[i] as u8).$check_u8_1_inv() {
- return false;
- }
- i += 1;
- }
- true
- }
- };
- ($self:ident, $check_int:ident, $check_u8_0_inv:ident, $check_u8_1_inv:ident) => {
- if N <= 4 {
- Aligned4::from_ascii_bytes(&$self.bytes).$check_int()
- } else if N <= 8 {
- Aligned8::from_ascii_bytes(&$self.bytes).$check_int()
- } else {
- // Won't panic because N is > 8
- if !($self.bytes[0] as u8).$check_u8_0_inv() {
- return false;
- }
- let mut i = 1;
- // Won't panic because self.bytes has length N
- #[allow(clippy::indexing_slicing)]
- while i < N && $self.bytes[i] as u8 != AsciiByte::B0 as u8 {
- if !($self.bytes[i] as u8).$check_u8_1_inv() {
- return false;
- }
- i += 1;
- }
- true
- }
- };
-}
-
-impl<const N: usize> TinyAsciiStr<N> {
- /// Checks if the value is composed of ASCII alphabetic characters:
- ///
- /// * U+0041 'A' ..= U+005A 'Z', or
- /// * U+0061 'a' ..= U+007A 'z'.
- ///
- /// # Examples
- ///
- /// ```
- /// use tinystr::TinyAsciiStr;
- ///
- /// let s1: TinyAsciiStr<4> = "Test".parse().expect("Failed to parse.");
- /// let s2: TinyAsciiStr<4> = "Te3t".parse().expect("Failed to parse.");
- ///
- /// assert!(s1.is_ascii_alphabetic());
- /// assert!(!s2.is_ascii_alphabetic());
- /// ```
- #[inline]
- #[must_use]
- pub const fn is_ascii_alphabetic(&self) -> bool {
- check_is!(self, is_ascii_alphabetic, is_ascii_alphabetic)
- }
-
- /// Checks if the value is composed of ASCII alphanumeric characters:
- ///
- /// * U+0041 'A' ..= U+005A 'Z', or
- /// * U+0061 'a' ..= U+007A 'z', or
- /// * U+0030 '0' ..= U+0039 '9'.
- ///
- /// # Examples
- ///
- /// ```
- /// use tinystr::TinyAsciiStr;
- ///
- /// let s1: TinyAsciiStr<4> = "A15b".parse().expect("Failed to parse.");
- /// let s2: TinyAsciiStr<4> = "[3@w".parse().expect("Failed to parse.");
- ///
- /// assert!(s1.is_ascii_alphanumeric());
- /// assert!(!s2.is_ascii_alphanumeric());
- /// ```
- #[inline]
- #[must_use]
- pub const fn is_ascii_alphanumeric(&self) -> bool {
- check_is!(self, is_ascii_alphanumeric, is_ascii_alphanumeric)
- }
-
- /// Checks if the value is composed of ASCII decimal digits:
- ///
- /// * U+0030 '0' ..= U+0039 '9'.
- ///
- /// # Examples
- ///
- /// ```
- /// use tinystr::TinyAsciiStr;
- ///
- /// let s1: TinyAsciiStr<4> = "312".parse().expect("Failed to parse.");
- /// let s2: TinyAsciiStr<4> = "3d".parse().expect("Failed to parse.");
- ///
- /// assert!(s1.is_ascii_numeric());
- /// assert!(!s2.is_ascii_numeric());
- /// ```
- #[inline]
- #[must_use]
- pub const fn is_ascii_numeric(&self) -> bool {
- check_is!(self, is_ascii_numeric, is_ascii_digit)
- }
-
- /// Checks if the value is in ASCII lower case.
- ///
- /// All letter characters are checked for case. Non-letter characters are ignored.
- ///
- /// # Examples
- ///
- /// ```
- /// use tinystr::TinyAsciiStr;
- ///
- /// let s1: TinyAsciiStr<4> = "teSt".parse().expect("Failed to parse.");
- /// let s2: TinyAsciiStr<4> = "test".parse().expect("Failed to parse.");
- /// let s3: TinyAsciiStr<4> = "001z".parse().expect("Failed to parse.");
- ///
- /// assert!(!s1.is_ascii_lowercase());
- /// assert!(s2.is_ascii_lowercase());
- /// assert!(s3.is_ascii_lowercase());
- /// ```
- #[inline]
- #[must_use]
- pub const fn is_ascii_lowercase(&self) -> bool {
- check_is!(
- self,
- is_ascii_lowercase,
- !is_ascii_uppercase,
- !is_ascii_uppercase
- )
- }
-
- /// Checks if the value is in ASCII title case.
- ///
- /// This verifies that the first character is ASCII uppercase and all others ASCII lowercase.
- /// Non-letter characters are ignored.
- ///
- /// # Examples
- ///
- /// ```
- /// use tinystr::TinyAsciiStr;
- ///
- /// let s1: TinyAsciiStr<4> = "teSt".parse().expect("Failed to parse.");
- /// let s2: TinyAsciiStr<4> = "Test".parse().expect("Failed to parse.");
- /// let s3: TinyAsciiStr<4> = "001z".parse().expect("Failed to parse.");
- ///
- /// assert!(!s1.is_ascii_titlecase());
- /// assert!(s2.is_ascii_titlecase());
- /// assert!(s3.is_ascii_titlecase());
- /// ```
- #[inline]
- #[must_use]
- pub const fn is_ascii_titlecase(&self) -> bool {
- check_is!(
- self,
- is_ascii_titlecase,
- !is_ascii_lowercase,
- !is_ascii_uppercase
- )
- }
-
- /// Checks if the value is in ASCII upper case.
- ///
- /// All letter characters are checked for case. Non-letter characters are ignored.
- ///
- /// # Examples
- ///
- /// ```
- /// use tinystr::TinyAsciiStr;
- ///
- /// let s1: TinyAsciiStr<4> = "teSt".parse().expect("Failed to parse.");
- /// let s2: TinyAsciiStr<4> = "TEST".parse().expect("Failed to parse.");
- /// let s3: TinyAsciiStr<4> = "001z".parse().expect("Failed to parse.");
- ///
- /// assert!(!s1.is_ascii_uppercase());
- /// assert!(s2.is_ascii_uppercase());
- /// assert!(!s3.is_ascii_uppercase());
- /// ```
- #[inline]
- #[must_use]
- pub const fn is_ascii_uppercase(&self) -> bool {
- check_is!(
- self,
- is_ascii_uppercase,
- !is_ascii_lowercase,
- !is_ascii_lowercase
- )
- }
-
- /// Checks if the value is composed of ASCII alphabetic lower case characters:
- ///
- /// * U+0061 'a' ..= U+007A 'z',
- ///
- /// # Examples
- ///
- /// ```
- /// use tinystr::TinyAsciiStr;
- ///
- /// let s1: TinyAsciiStr<4> = "Test".parse().expect("Failed to parse.");
- /// let s2: TinyAsciiStr<4> = "Te3t".parse().expect("Failed to parse.");
- /// let s3: TinyAsciiStr<4> = "teSt".parse().expect("Failed to parse.");
- /// let s4: TinyAsciiStr<4> = "test".parse().expect("Failed to parse.");
- /// let s5: TinyAsciiStr<4> = "001z".parse().expect("Failed to parse.");
- ///
- /// assert!(!s1.is_ascii_alphabetic_lowercase());
- /// assert!(!s2.is_ascii_alphabetic_lowercase());
- /// assert!(!s3.is_ascii_alphabetic_lowercase());
- /// assert!(s4.is_ascii_alphabetic_lowercase());
- /// assert!(!s5.is_ascii_alphabetic_lowercase());
- /// ```
- #[inline]
- #[must_use]
- pub const fn is_ascii_alphabetic_lowercase(&self) -> bool {
- check_is!(
- self,
- is_ascii_alphabetic_lowercase,
- is_ascii_lowercase,
- is_ascii_lowercase
- )
- }
-
- /// Checks if the value is composed of ASCII alphabetic, with the first character being ASCII uppercase, and all others ASCII lowercase.
- ///
- /// # Examples
- ///
- /// ```
- /// use tinystr::TinyAsciiStr;
- ///
- /// let s1: TinyAsciiStr<4> = "Test".parse().expect("Failed to parse.");
- /// let s2: TinyAsciiStr<4> = "Te3t".parse().expect("Failed to parse.");
- /// let s3: TinyAsciiStr<4> = "teSt".parse().expect("Failed to parse.");
- /// let s4: TinyAsciiStr<4> = "test".parse().expect("Failed to parse.");
- /// let s5: TinyAsciiStr<4> = "001z".parse().expect("Failed to parse.");
- ///
- /// assert!(s1.is_ascii_alphabetic_titlecase());
- /// assert!(!s2.is_ascii_alphabetic_titlecase());
- /// assert!(!s3.is_ascii_alphabetic_titlecase());
- /// assert!(!s4.is_ascii_alphabetic_titlecase());
- /// assert!(!s5.is_ascii_alphabetic_titlecase());
- /// ```
- #[inline]
- #[must_use]
- pub const fn is_ascii_alphabetic_titlecase(&self) -> bool {
- check_is!(
- self,
- is_ascii_alphabetic_titlecase,
- is_ascii_uppercase,
- is_ascii_lowercase
- )
- }
-
- /// Checks if the value is composed of ASCII alphabetic upper case characters:
- ///
- /// * U+0041 'A' ..= U+005A 'Z',
- ///
- /// # Examples
- ///
- /// ```
- /// use tinystr::TinyAsciiStr;
- ///
- /// let s1: TinyAsciiStr<4> = "Test".parse().expect("Failed to parse.");
- /// let s2: TinyAsciiStr<4> = "Te3t".parse().expect("Failed to parse.");
- /// let s3: TinyAsciiStr<4> = "teSt".parse().expect("Failed to parse.");
- /// let s4: TinyAsciiStr<4> = "TEST".parse().expect("Failed to parse.");
- /// let s5: TinyAsciiStr<4> = "001z".parse().expect("Failed to parse.");
- ///
- /// assert!(!s1.is_ascii_alphabetic_uppercase());
- /// assert!(!s2.is_ascii_alphabetic_uppercase());
- /// assert!(!s3.is_ascii_alphabetic_uppercase());
- /// assert!(s4.is_ascii_alphabetic_uppercase());
- /// assert!(!s5.is_ascii_alphabetic_uppercase());
- /// ```
- #[inline]
- #[must_use]
- pub const fn is_ascii_alphabetic_uppercase(&self) -> bool {
- check_is!(
- self,
- is_ascii_alphabetic_uppercase,
- is_ascii_uppercase,
- is_ascii_uppercase
- )
- }
-}
-
-macro_rules! to {
- ($self:ident, $to:ident, $later_char_to:ident $(,$first_char_to:ident)?) => {{
- let mut i = 0;
- if N <= 4 {
- let aligned = Aligned4::from_ascii_bytes(&$self.bytes).$to().to_ascii_bytes();
- // Won't panic because self.bytes has length N and aligned has length >= N
- #[allow(clippy::indexing_slicing)]
- while i < N {
- $self.bytes[i] = aligned[i];
- i += 1;
- }
- } else if N <= 8 {
- let aligned = Aligned8::from_ascii_bytes(&$self.bytes).$to().to_ascii_bytes();
- // Won't panic because self.bytes has length N and aligned has length >= N
- #[allow(clippy::indexing_slicing)]
- while i < N {
- $self.bytes[i] = aligned[i];
- i += 1;
- }
- } else {
- // Won't panic because self.bytes has length N
- #[allow(clippy::indexing_slicing)]
- while i < N && $self.bytes[i] as u8 != AsciiByte::B0 as u8 {
- // SAFETY: AsciiByte is repr(u8) and has same size as u8
- unsafe {
- $self.bytes[i] = core::mem::transmute::<u8, AsciiByte>(
- ($self.bytes[i] as u8).$later_char_to()
- );
- }
- i += 1;
- }
- // SAFETY: AsciiByte is repr(u8) and has same size as u8
- $(
- $self.bytes[0] = unsafe {
- core::mem::transmute::<u8, AsciiByte>(($self.bytes[0] as u8).$first_char_to())
- };
- )?
- }
- $self
- }};
-}
-
-impl<const N: usize> TinyAsciiStr<N> {
- /// Converts this type to its ASCII lower case equivalent in-place.
- ///
- /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z', other characters are unchanged.
- ///
- /// # Examples
- ///
- /// ```
- /// use tinystr::TinyAsciiStr;
- ///
- /// let s1: TinyAsciiStr<4> = "TeS3".parse().expect("Failed to parse.");
- ///
- /// assert_eq!(&*s1.to_ascii_lowercase(), "tes3");
- /// ```
- #[inline]
- #[must_use]
- pub const fn to_ascii_lowercase(mut self) -> Self {
- to!(self, to_ascii_lowercase, to_ascii_lowercase)
- }
-
- /// Converts this type to its ASCII title case equivalent in-place.
- ///
- /// The first character is converted to ASCII uppercase; the remaining characters
- /// are converted to ASCII lowercase.
- ///
- /// # Examples
- ///
- /// ```
- /// use tinystr::TinyAsciiStr;
- ///
- /// let s1: TinyAsciiStr<4> = "teSt".parse().expect("Failed to parse.");
- ///
- /// assert_eq!(&*s1.to_ascii_titlecase(), "Test");
- /// ```
- #[inline]
- #[must_use]
- pub const fn to_ascii_titlecase(mut self) -> Self {
- to!(
- self,
- to_ascii_titlecase,
- to_ascii_lowercase,
- to_ascii_uppercase
- )
- }
-
- /// Converts this type to its ASCII upper case equivalent in-place.
- ///
- /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z', other characters are unchanged.
- ///
- /// # Examples
- ///
- /// ```
- /// use tinystr::TinyAsciiStr;
- ///
- /// let s1: TinyAsciiStr<4> = "Tes3".parse().expect("Failed to parse.");
- ///
- /// assert_eq!(&*s1.to_ascii_uppercase(), "TES3");
- /// ```
- #[inline]
- #[must_use]
- pub const fn to_ascii_uppercase(mut self) -> Self {
- to!(self, to_ascii_uppercase, to_ascii_uppercase)
- }
-}
-
-impl<const N: usize> fmt::Debug for TinyAsciiStr<N> {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- fmt::Debug::fmt(self.as_str(), f)
- }
-}
-
-impl<const N: usize> fmt::Display for TinyAsciiStr<N> {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- fmt::Display::fmt(self.as_str(), f)
- }
-}
-
-impl<const N: usize> Deref for TinyAsciiStr<N> {
- type Target = str;
- #[inline]
- fn deref(&self) -> &str {
- self.as_str()
- }
-}
-
-impl<const N: usize> Borrow<str> for TinyAsciiStr<N> {
- #[inline]
- fn borrow(&self) -> &str {
- self.as_str()
- }
-}
-
-impl<const N: usize> FromStr for TinyAsciiStr<N> {
- type Err = ParseError;
- #[inline]
- fn from_str(s: &str) -> Result<Self, Self::Err> {
- Self::try_from_str(s)
- }
-}
-
-impl<const N: usize> PartialEq<str> for TinyAsciiStr<N> {
- fn eq(&self, other: &str) -> bool {
- self.deref() == other
- }
-}
-
-impl<const N: usize> PartialEq<&str> for TinyAsciiStr<N> {
- fn eq(&self, other: &&str) -> bool {
- self.deref() == *other
- }
-}
-
-#[cfg(feature = "alloc")]
-impl<const N: usize> PartialEq<alloc::string::String> for TinyAsciiStr<N> {
- fn eq(&self, other: &alloc::string::String) -> bool {
- self.deref() == other.deref()
- }
-}
-
-#[cfg(feature = "alloc")]
-impl<const N: usize> PartialEq<TinyAsciiStr<N>> for alloc::string::String {
- fn eq(&self, other: &TinyAsciiStr<N>) -> bool {
- self.deref() == other.deref()
- }
-}
-
-#[cfg(test)]
-mod test {
- use super::*;
- use rand::distributions::Distribution;
- use rand::distributions::Standard;
- use rand::rngs::SmallRng;
- use rand::seq::SliceRandom;
- use rand::SeedableRng;
-
- const STRINGS: [&str; 26] = [
- "Latn",
- "laTn",
- "windows",
- "AR",
- "Hans",
- "macos",
- "AT",
- "infiniband",
- "FR",
- "en",
- "Cyrl",
- "FromIntegral",
- "NO",
- "419",
- "MacintoshOSX2019",
- "a3z",
- "A3z",
- "A3Z",
- "a3Z",
- "3A",
- "3Z",
- "3a",
- "3z",
- "@@[`{",
- "UK",
- "E12",
- ];
-
- fn gen_strings(num_strings: usize, allowed_lengths: &[usize]) -> Vec<String> {
- let mut rng = SmallRng::seed_from_u64(2022);
- // Need to do this in 2 steps since the RNG is needed twice
- let string_lengths = core::iter::repeat_with(|| *allowed_lengths.choose(&mut rng).unwrap())
- .take(num_strings)
- .collect::<Vec<usize>>();
- string_lengths
- .iter()
- .map(|len| {
- Standard
- .sample_iter(&mut rng)
- .filter(|b: &u8| *b > 0 && *b < 0x80)
- .take(*len)
- .collect::<Vec<u8>>()
- })
- .map(|byte_vec| String::from_utf8(byte_vec).expect("All ASCII"))
- .collect()
- }
-
- fn check_operation<T, F1, F2, const N: usize>(reference_f: F1, tinystr_f: F2)
- where
- F1: Fn(&str) -> T,
- F2: Fn(TinyAsciiStr<N>) -> T,
- T: core::fmt::Debug + core::cmp::PartialEq,
- {
- for s in STRINGS
- .into_iter()
- .map(str::to_owned)
- .chain(gen_strings(100, &[3, 4, 5, 8, 12]))
- {
- let t = match TinyAsciiStr::<N>::from_str(&s) {
- Ok(t) => t,
- Err(ParseError::TooLong { .. }) => continue,
- Err(e) => panic!("{}", e),
- };
- let expected = reference_f(&s);
- let actual = tinystr_f(t);
- assert_eq!(expected, actual, "TinyAsciiStr<{N}>: {s:?}");
-
- let s_utf16: Vec<u16> = s.encode_utf16().collect();
- let t = match TinyAsciiStr::<N>::try_from_utf16(&s_utf16) {
- Ok(t) => t,
- Err(ParseError::TooLong { .. }) => continue,
- Err(e) => panic!("{}", e),
- };
- let expected = reference_f(&s);
- let actual = tinystr_f(t);
- assert_eq!(expected, actual, "TinyAsciiStr<{N}>: {s:?}");
- }
- }
-
- #[test]
- fn test_is_ascii_alphabetic() {
- fn check<const N: usize>() {
- check_operation(
- |s| s.chars().all(|c| c.is_ascii_alphabetic()),
- |t: TinyAsciiStr<N>| TinyAsciiStr::is_ascii_alphabetic(&t),
- )
- }
- check::<2>();
- check::<3>();
- check::<4>();
- check::<5>();
- check::<8>();
- check::<16>();
- }
-
- #[test]
- fn test_is_ascii_alphanumeric() {
- fn check<const N: usize>() {
- check_operation(
- |s| s.chars().all(|c| c.is_ascii_alphanumeric()),
- |t: TinyAsciiStr<N>| TinyAsciiStr::is_ascii_alphanumeric(&t),
- )
- }
- check::<2>();
- check::<3>();
- check::<4>();
- check::<5>();
- check::<8>();
- check::<16>();
- }
-
- #[test]
- fn test_is_ascii_numeric() {
- fn check<const N: usize>() {
- check_operation(
- |s| s.chars().all(|c| c.is_ascii_digit()),
- |t: TinyAsciiStr<N>| TinyAsciiStr::is_ascii_numeric(&t),
- )
- }
- check::<2>();
- check::<3>();
- check::<4>();
- check::<5>();
- check::<8>();
- check::<16>();
- }
-
- #[test]
- fn test_is_ascii_lowercase() {
- fn check<const N: usize>() {
- check_operation(
- |s| {
- s == TinyAsciiStr::<16>::try_from_str(s)
- .unwrap()
- .to_ascii_lowercase()
- .as_str()
- },
- |t: TinyAsciiStr<N>| TinyAsciiStr::is_ascii_lowercase(&t),
- )
- }
- check::<2>();
- check::<3>();
- check::<4>();
- check::<5>();
- check::<8>();
- check::<16>();
- }
-
- #[test]
- fn test_is_ascii_titlecase() {
- fn check<const N: usize>() {
- check_operation(
- |s| {
- s == TinyAsciiStr::<16>::try_from_str(s)
- .unwrap()
- .to_ascii_titlecase()
- .as_str()
- },
- |t: TinyAsciiStr<N>| TinyAsciiStr::is_ascii_titlecase(&t),
- )
- }
- check::<2>();
- check::<3>();
- check::<4>();
- check::<5>();
- check::<8>();
- check::<16>();
- }
-
- #[test]
- fn test_is_ascii_uppercase() {
- fn check<const N: usize>() {
- check_operation(
- |s| {
- s == TinyAsciiStr::<16>::try_from_str(s)
- .unwrap()
- .to_ascii_uppercase()
- .as_str()
- },
- |t: TinyAsciiStr<N>| TinyAsciiStr::is_ascii_uppercase(&t),
- )
- }
- check::<2>();
- check::<3>();
- check::<4>();
- check::<5>();
- check::<8>();
- check::<16>();
- }
-
- #[test]
- fn test_is_ascii_alphabetic_lowercase() {
- fn check<const N: usize>() {
- check_operation(
- |s| {
- // Check alphabetic
- s.chars().all(|c| c.is_ascii_alphabetic()) &&
- // Check lowercase
- s == TinyAsciiStr::<16>::try_from_str(s)
- .unwrap()
- .to_ascii_lowercase()
- .as_str()
- },
- |t: TinyAsciiStr<N>| TinyAsciiStr::is_ascii_alphabetic_lowercase(&t),
- )
- }
- check::<2>();
- check::<3>();
- check::<4>();
- check::<5>();
- check::<8>();
- check::<16>();
- }
-
- #[test]
- fn test_is_ascii_alphabetic_titlecase() {
- fn check<const N: usize>() {
- check_operation(
- |s| {
- // Check alphabetic
- s.chars().all(|c| c.is_ascii_alphabetic()) &&
- // Check titlecase
- s == TinyAsciiStr::<16>::try_from_str(s)
- .unwrap()
- .to_ascii_titlecase()
- .as_str()
- },
- |t: TinyAsciiStr<N>| TinyAsciiStr::is_ascii_alphabetic_titlecase(&t),
- )
- }
- check::<2>();
- check::<3>();
- check::<4>();
- check::<5>();
- check::<8>();
- check::<16>();
- }
-
- #[test]
- fn test_is_ascii_alphabetic_uppercase() {
- fn check<const N: usize>() {
- check_operation(
- |s| {
- // Check alphabetic
- s.chars().all(|c| c.is_ascii_alphabetic()) &&
- // Check uppercase
- s == TinyAsciiStr::<16>::try_from_str(s)
- .unwrap()
- .to_ascii_uppercase()
- .as_str()
- },
- |t: TinyAsciiStr<N>| TinyAsciiStr::is_ascii_alphabetic_uppercase(&t),
- )
- }
- check::<2>();
- check::<3>();
- check::<4>();
- check::<5>();
- check::<8>();
- check::<16>();
- }
-
- #[test]
- fn test_to_ascii_lowercase() {
- fn check<const N: usize>() {
- check_operation(
- |s| {
- s.chars()
- .map(|c| c.to_ascii_lowercase())
- .collect::<String>()
- },
- |t: TinyAsciiStr<N>| TinyAsciiStr::to_ascii_lowercase(t).as_str().to_owned(),
- )
- }
- check::<2>();
- check::<3>();
- check::<4>();
- check::<5>();
- check::<8>();
- check::<16>();
- }
-
- #[test]
- fn test_to_ascii_titlecase() {
- fn check<const N: usize>() {
- check_operation(
- |s| {
- let mut r = s
- .chars()
- .map(|c| c.to_ascii_lowercase())
- .collect::<String>();
- // Safe because the string is nonempty and an ASCII string
- unsafe { r.as_bytes_mut()[0].make_ascii_uppercase() };
- r
- },
- |t: TinyAsciiStr<N>| TinyAsciiStr::to_ascii_titlecase(t).as_str().to_owned(),
- )
- }
- check::<2>();
- check::<3>();
- check::<4>();
- check::<5>();
- check::<8>();
- check::<16>();
- }
-
- #[test]
- fn test_to_ascii_uppercase() {
- fn check<const N: usize>() {
- check_operation(
- |s| {
- s.chars()
- .map(|c| c.to_ascii_uppercase())
- .collect::<String>()
- },
- |t: TinyAsciiStr<N>| TinyAsciiStr::to_ascii_uppercase(t).as_str().to_owned(),
- )
- }
- check::<2>();
- check::<3>();
- check::<4>();
- check::<5>();
- check::<8>();
- check::<16>();
- }
-
- #[test]
- fn lossy_constructor() {
- assert_eq!(TinyAsciiStr::<4>::from_utf8_lossy(b"", b'?').as_str(), "");
- assert_eq!(
- TinyAsciiStr::<4>::from_utf8_lossy(b"oh\0o", b'?').as_str(),
- "oh?o"
- );
- assert_eq!(
- TinyAsciiStr::<4>::from_utf8_lossy(b"\0", b'?').as_str(),
- "?"
- );
- assert_eq!(
- TinyAsciiStr::<4>::from_utf8_lossy(b"toolong", b'?').as_str(),
- "tool"
- );
- assert_eq!(
- TinyAsciiStr::<4>::from_utf8_lossy(&[b'a', 0x80, 0xFF, b'1'], b'?').as_str(),
- "a??1"
- );
- }
-}
diff --git a/vendor/tinystr/src/asciibyte.rs b/vendor/tinystr/src/asciibyte.rs
deleted file mode 100644
index f41a0334..00000000
--- a/vendor/tinystr/src/asciibyte.rs
+++ /dev/null
@@ -1,145 +0,0 @@
-// This file is part of ICU4X. For terms of use, please see the file
-// called LICENSE at the top level of the ICU4X source tree
-// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
-
-#[repr(u8)]
-#[allow(dead_code)]
-#[derive(PartialEq, Eq, Ord, PartialOrd, Copy, Clone, Hash)]
-pub enum AsciiByte {
- B0 = 0,
- B1 = 1,
- B2 = 2,
- B3 = 3,
- B4 = 4,
- B5 = 5,
- B6 = 6,
- B7 = 7,
- B8 = 8,
- B9 = 9,
- B10 = 10,
- B11 = 11,
- B12 = 12,
- B13 = 13,
- B14 = 14,
- B15 = 15,
- B16 = 16,
- B17 = 17,
- B18 = 18,
- B19 = 19,
- B20 = 20,
- B21 = 21,
- B22 = 22,
- B23 = 23,
- B24 = 24,
- B25 = 25,
- B26 = 26,
- B27 = 27,
- B28 = 28,
- B29 = 29,
- B30 = 30,
- B31 = 31,
- B32 = 32,
- B33 = 33,
- B34 = 34,
- B35 = 35,
- B36 = 36,
- B37 = 37,
- B38 = 38,
- B39 = 39,
- B40 = 40,
- B41 = 41,
- B42 = 42,
- B43 = 43,
- B44 = 44,
- B45 = 45,
- B46 = 46,
- B47 = 47,
- B48 = 48,
- B49 = 49,
- B50 = 50,
- B51 = 51,
- B52 = 52,
- B53 = 53,
- B54 = 54,
- B55 = 55,
- B56 = 56,
- B57 = 57,
- B58 = 58,
- B59 = 59,
- B60 = 60,
- B61 = 61,
- B62 = 62,
- B63 = 63,
- B64 = 64,
- B65 = 65,
- B66 = 66,
- B67 = 67,
- B68 = 68,
- B69 = 69,
- B70 = 70,
- B71 = 71,
- B72 = 72,
- B73 = 73,
- B74 = 74,
- B75 = 75,
- B76 = 76,
- B77 = 77,
- B78 = 78,
- B79 = 79,
- B80 = 80,
- B81 = 81,
- B82 = 82,
- B83 = 83,
- B84 = 84,
- B85 = 85,
- B86 = 86,
- B87 = 87,
- B88 = 88,
- B89 = 89,
- B90 = 90,
- B91 = 91,
- B92 = 92,
- B93 = 93,
- B94 = 94,
- B95 = 95,
- B96 = 96,
- B97 = 97,
- B98 = 98,
- B99 = 99,
- B100 = 100,
- B101 = 101,
- B102 = 102,
- B103 = 103,
- B104 = 104,
- B105 = 105,
- B106 = 106,
- B107 = 107,
- B108 = 108,
- B109 = 109,
- B110 = 110,
- B111 = 111,
- B112 = 112,
- B113 = 113,
- B114 = 114,
- B115 = 115,
- B116 = 116,
- B117 = 117,
- B118 = 118,
- B119 = 119,
- B120 = 120,
- B121 = 121,
- B122 = 122,
- B123 = 123,
- B124 = 124,
- B125 = 125,
- B126 = 126,
- B127 = 127,
-}
-
-impl AsciiByte {
- // Convert [u8; N] to [AsciiByte; N]
- #[inline]
- pub const unsafe fn to_ascii_byte_array<const N: usize>(bytes: &[u8; N]) -> [AsciiByte; N] {
- *(bytes as *const [u8; N] as *const [AsciiByte; N])
- }
-}
diff --git a/vendor/tinystr/src/databake.rs b/vendor/tinystr/src/databake.rs
deleted file mode 100644
index 748d23ac..00000000
--- a/vendor/tinystr/src/databake.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-// This file is part of ICU4X. For terms of use, please see the file
-// called LICENSE at the top level of the ICU4X source tree
-// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
-
-use crate::TinyAsciiStr;
-use crate::UnvalidatedTinyAsciiStr;
-use databake::*;
-
-impl<const N: usize> Bake for TinyAsciiStr<N> {
- fn bake(&self, env: &CrateEnv) -> TokenStream {
- env.insert("tinystr");
- let string = self.as_str();
- quote! {
- tinystr::tinystr!(#N, #string)
- }
- }
-}
-
-impl<const N: usize> BakeSize for TinyAsciiStr<N> {
- fn borrows_size(&self) -> usize {
- 0
- }
-}
-
-impl<const N: usize> databake::Bake for UnvalidatedTinyAsciiStr<N> {
- fn bake(&self, env: &databake::CrateEnv) -> databake::TokenStream {
- match self.try_into_tinystr() {
- Ok(tiny) => {
- let tiny = tiny.bake(env);
- databake::quote! {
- #tiny.to_unvalidated()
- }
- }
- Err(_) => {
- let bytes = self.0.bake(env);
- env.insert("tinystr");
- databake::quote! {
- tinystr::UnvalidatedTinyAsciiStr::from_utf8_unchecked(#bytes)
- }
- }
- }
- }
-}
-
-impl<const N: usize> databake::BakeSize for UnvalidatedTinyAsciiStr<N> {
- fn borrows_size(&self) -> usize {
- 0
- }
-}
-
-#[test]
-fn test() {
- test_bake!(
- TinyAsciiStr<10>,
- const,
- crate::tinystr!(10usize, "foo"),
- tinystr
- );
-}
-
-#[test]
-fn test_unvalidated() {
- test_bake!(
- UnvalidatedTinyAsciiStr<10>,
- const,
- crate::tinystr!(10usize, "foo").to_unvalidated(),
- tinystr
- );
- test_bake!(
- UnvalidatedTinyAsciiStr<3>,
- const,
- crate::UnvalidatedTinyAsciiStr::from_utf8_unchecked(*b"AB\xCD"),
- tinystr
- );
-}
diff --git a/vendor/tinystr/src/error.rs b/vendor/tinystr/src/error.rs
deleted file mode 100644
index ea1ab212..00000000
--- a/vendor/tinystr/src/error.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-// This file is part of ICU4X. For terms of use, please see the file
-// called LICENSE at the top level of the ICU4X source tree
-// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
-
-use displaydoc::Display;
-
-impl core::error::Error for ParseError {}
-
-#[derive(Display, Debug, PartialEq, Eq)]
-#[non_exhaustive]
-pub enum ParseError {
- #[displaydoc("found string of larger length {len} when constructing string of length {max}")]
- TooLong { max: usize, len: usize },
- #[displaydoc("tinystr types do not support strings with null bytes")]
- ContainsNull,
- #[displaydoc("attempted to construct TinyAsciiStr from a non-ASCII string")]
- NonAscii,
-}
diff --git a/vendor/tinystr/src/int_ops.rs b/vendor/tinystr/src/int_ops.rs
deleted file mode 100644
index 7bdb3633..00000000
--- a/vendor/tinystr/src/int_ops.rs
+++ /dev/null
@@ -1,315 +0,0 @@
-// This file is part of ICU4X. For terms of use, please see the file
-// called LICENSE at the top level of the ICU4X source tree
-// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
-
-use crate::asciibyte::AsciiByte;
-
-/// Internal helper struct that performs operations on aligned integers.
-/// Supports strings up to 4 bytes long.
-#[repr(transparent)]
-pub struct Aligned4(u32);
-
-impl Aligned4 {
- /// # Panics
- /// Panics if N is greater than 4
- #[inline]
- pub const fn from_utf8<const N: usize>(src: &[u8; N]) -> Self {
- let mut bytes = [0; 4];
- let mut i = 0;
- // The function documentation defines when panics may occur
- #[allow(clippy::indexing_slicing)]
- while i < N {
- bytes[i] = src[i];
- i += 1;
- }
- Self(u32::from_ne_bytes(bytes))
- }
-
- #[inline]
- pub const fn from_ascii_bytes<const N: usize>(src: &[AsciiByte; N]) -> Self {
- Self::from_utf8::<N>(unsafe { core::mem::transmute::<&[AsciiByte; N], &[u8; N]>(src) })
- }
-
- #[inline]
- pub const fn to_bytes(&self) -> [u8; 4] {
- self.0.to_ne_bytes()
- }
-
- #[inline]
- pub const fn to_ascii_bytes(&self) -> [AsciiByte; 4] {
- unsafe { core::mem::transmute(self.to_bytes()) }
- }
-
- pub const fn len(&self) -> usize {
- let word = self.0;
- #[cfg(target_endian = "little")]
- let len = (4 - word.leading_zeros() / 8) as usize;
- #[cfg(target_endian = "big")]
- let len = (4 - word.trailing_zeros() / 8) as usize;
- len
- }
-
- pub const fn is_ascii_alphabetic(&self) -> bool {
- let word = self.0;
- // Each of the following bitmasks set *the high bit* (0x8) to 0 for valid and 1 for invalid.
- // `mask` sets all NUL bytes to 0.
- let mask = (word + 0x7f7f_7f7f) & 0x8080_8080;
- // `lower` converts the string to lowercase. It may also change the value of non-alpha
- // characters, but this does not matter for the alphabetic test that follows.
- let lower = word | 0x2020_2020;
- // `alpha` sets all alphabetic bytes to 0. We only need check for lowercase characters.
- let alpha = !(lower + 0x1f1f_1f1f) | (lower + 0x0505_0505);
- // The overall string is valid if every character passes at least one test.
- // We performed two tests here: non-NUL (`mask`) and alphabetic (`alpha`).
- (alpha & mask) == 0
- }
-
- pub const fn is_ascii_alphanumeric(&self) -> bool {
- let word = self.0;
- // See explanatory comments in is_ascii_alphabetic
- let mask = (word + 0x7f7f_7f7f) & 0x8080_8080;
- let numeric = !(word + 0x5050_5050) | (word + 0x4646_4646);
- let lower = word | 0x2020_2020;
- let alpha = !(lower + 0x1f1f_1f1f) | (lower + 0x0505_0505);
- (alpha & numeric & mask) == 0
- }
-
- pub const fn is_ascii_numeric(&self) -> bool {
- let word = self.0;
- // See explanatory comments in is_ascii_alphabetic
- let mask = (word + 0x7f7f_7f7f) & 0x8080_8080;
- let numeric = !(word + 0x5050_5050) | (word + 0x4646_4646);
- (numeric & mask) == 0
- }
-
- pub const fn is_ascii_lowercase(&self) -> bool {
- let word = self.0;
- // For efficiency, this function tests for an invalid string rather than a valid string.
- // A string is ASCII lowercase iff it contains no uppercase ASCII characters.
- // `invalid_case` sets all uppercase ASCII characters to 0 and all others to 1.
- let invalid_case = !(word + 0x3f3f_3f3f) | (word + 0x2525_2525);
- // The string is valid if it contains no invalid characters (if all high bits are 1).
- (invalid_case & 0x8080_8080) == 0x8080_8080
- }
-
- pub const fn is_ascii_titlecase(&self) -> bool {
- let word = self.0;
- // See explanatory comments in is_ascii_lowercase
- let invalid_case = if cfg!(target_endian = "little") {
- !(word + 0x3f3f_3f1f) | (word + 0x2525_2505)
- } else {
- !(word + 0x1f3f_3f3f) | (word + 0x0525_2525)
- };
- (invalid_case & 0x8080_8080) == 0x8080_8080
- }
-
- pub const fn is_ascii_uppercase(&self) -> bool {
- let word = self.0;
- // See explanatory comments in is_ascii_lowercase
- let invalid_case = !(word + 0x1f1f_1f1f) | (word + 0x0505_0505);
- (invalid_case & 0x8080_8080) == 0x8080_8080
- }
-
- pub const fn is_ascii_alphabetic_lowercase(&self) -> bool {
- let word = self.0;
- // `mask` sets all NUL bytes to 0.
- let mask = (word + 0x7f7f_7f7f) & 0x8080_8080;
- // `lower_alpha` sets all lowercase ASCII characters to 0 and all others to 1.
- let lower_alpha = !(word + 0x1f1f_1f1f) | (word + 0x0505_0505);
- // The overall string is valid if every character passes at least one test.
- // We performed two tests here: non-NUL (`mask`) and lowercase ASCII character (`alpha`).
- (lower_alpha & mask) == 0
- }
-
- pub const fn is_ascii_alphabetic_titlecase(&self) -> bool {
- let word = self.0;
- // See explanatory comments in is_ascii_alphabetic_lowercase
- let mask = (word + 0x7f7f_7f7f) & 0x8080_8080;
- let title_case = if cfg!(target_endian = "little") {
- !(word + 0x1f1f_1f3f) | (word + 0x0505_0525)
- } else {
- !(word + 0x3f1f_1f1f) | (word + 0x2505_0505)
- };
- (title_case & mask) == 0
- }
-
- pub const fn is_ascii_alphabetic_uppercase(&self) -> bool {
- let word = self.0;
- // See explanatory comments in is_ascii_alphabetic_lowercase
- let mask = (word + 0x7f7f_7f7f) & 0x8080_8080;
- let upper_alpha = !(word + 0x3f3f_3f3f) | (word + 0x2525_2525);
- (upper_alpha & mask) == 0
- }
-
- pub const fn to_ascii_lowercase(&self) -> Self {
- let word = self.0;
- let result = word | (((word + 0x3f3f_3f3f) & !(word + 0x2525_2525) & 0x8080_8080) >> 2);
- Self(result)
- }
-
- pub const fn to_ascii_titlecase(&self) -> Self {
- let word = self.0.to_le();
- let mask = ((word + 0x3f3f_3f1f) & !(word + 0x2525_2505) & 0x8080_8080) >> 2;
- let result = (word | mask) & !(0x20 & mask);
- Self(u32::from_le(result))
- }
-
- pub const fn to_ascii_uppercase(&self) -> Self {
- let word = self.0;
- let result = word & !(((word + 0x1f1f_1f1f) & !(word + 0x0505_0505) & 0x8080_8080) >> 2);
- Self(result)
- }
-}
-
-/// Internal helper struct that performs operations on aligned integers.
-/// Supports strings up to 8 bytes long.
-#[repr(transparent)]
-pub struct Aligned8(u64);
-
-impl Aligned8 {
- /// # Panics
- /// Panics if N is greater than 8
- #[inline]
- pub const fn from_utf8<const N: usize>(src: &[u8; N]) -> Self {
- let mut bytes = [0; 8];
- let mut i = 0;
- // The function documentation defines when panics may occur
- #[allow(clippy::indexing_slicing)]
- while i < N {
- bytes[i] = src[i];
- i += 1;
- }
- Self(u64::from_ne_bytes(bytes))
- }
-
- #[inline]
- pub const fn from_ascii_bytes<const N: usize>(src: &[AsciiByte; N]) -> Self {
- Self::from_utf8::<N>(unsafe { core::mem::transmute::<&[AsciiByte; N], &[u8; N]>(src) })
- }
-
- #[inline]
- pub const fn to_bytes(&self) -> [u8; 8] {
- self.0.to_ne_bytes()
- }
-
- #[inline]
- pub const fn to_ascii_bytes(&self) -> [AsciiByte; 8] {
- unsafe { core::mem::transmute(self.to_bytes()) }
- }
-
- pub const fn len(&self) -> usize {
- let word = self.0;
- #[cfg(target_endian = "little")]
- let len = (8 - word.leading_zeros() / 8) as usize;
- #[cfg(target_endian = "big")]
- let len = (8 - word.trailing_zeros() / 8) as usize;
- len
- }
-
- pub const fn is_ascii_alphabetic(&self) -> bool {
- let word = self.0;
- let mask = (word + 0x7f7f_7f7f_7f7f_7f7f) & 0x8080_8080_8080_8080;
- let lower = word | 0x2020_2020_2020_2020;
- let alpha = !(lower + 0x1f1f_1f1f_1f1f_1f1f) | (lower + 0x0505_0505_0505_0505);
- (alpha & mask) == 0
- }
-
- pub const fn is_ascii_alphanumeric(&self) -> bool {
- let word = self.0;
- let mask = (word + 0x7f7f_7f7f_7f7f_7f7f) & 0x8080_8080_8080_8080;
- let numeric = !(word + 0x5050_5050_5050_5050) | (word + 0x4646_4646_4646_4646);
- let lower = word | 0x2020_2020_2020_2020;
- let alpha = !(lower + 0x1f1f_1f1f_1f1f_1f1f) | (lower + 0x0505_0505_0505_0505);
- (alpha & numeric & mask) == 0
- }
-
- pub const fn is_ascii_numeric(&self) -> bool {
- let word = self.0;
- let mask = (word + 0x7f7f_7f7f_7f7f_7f7f) & 0x8080_8080_8080_8080;
- let numeric = !(word + 0x5050_5050_5050_5050) | (word + 0x4646_4646_4646_4646);
- (numeric & mask) == 0
- }
-
- pub const fn is_ascii_lowercase(&self) -> bool {
- let word = self.0;
- let invalid_case = !(word + 0x3f3f_3f3f_3f3f_3f3f) | (word + 0x2525_2525_2525_2525);
- (invalid_case & 0x8080_8080_8080_8080) == 0x8080_8080_8080_8080
- }
-
- pub const fn is_ascii_titlecase(&self) -> bool {
- let word = self.0;
- let invalid_case = if cfg!(target_endian = "little") {
- !(word + 0x3f3f_3f3f_3f3f_3f1f) | (word + 0x2525_2525_2525_2505)
- } else {
- !(word + 0x1f3f_3f3f_3f3f_3f3f) | (word + 0x0525_2525_2525_2525)
- };
- (invalid_case & 0x8080_8080_8080_8080) == 0x8080_8080_8080_8080
- }
-
- pub const fn is_ascii_uppercase(&self) -> bool {
- let word = self.0;
- let invalid_case = !(word + 0x1f1f_1f1f_1f1f_1f1f) | (word + 0x0505_0505_0505_0505);
- (invalid_case & 0x8080_8080_8080_8080) == 0x8080_8080_8080_8080
- }
-
- pub const fn is_ascii_alphabetic_lowercase(&self) -> bool {
- let word = self.0;
- // `mask` sets all NUL bytes to 0.
- let mask = (word + 0x7f7f_7f7f_7f7f_7f7f) & 0x8080_8080_8080_8080;
- // `lower_alpha` sets all lowercase ASCII characters to 0 and all others to 1.
- let lower_alpha = !(word + 0x1f1f_1f1f_1f1f_1f1f) | (word + 0x0505_0505_0505_0505);
- // The overall string is valid if every character passes at least one test.
- // We performed two tests here: non-NUL (`mask`) and lowercase ASCII character (`alpha`).
- (lower_alpha & mask) == 0
- }
-
- pub const fn is_ascii_alphabetic_titlecase(&self) -> bool {
- let word = self.0;
- // See explanatory comments in is_ascii_alphabetic_lowercase
- let mask = (word + 0x7f7f_7f7f_7f7f_7f7f) & 0x8080_8080_8080_8080;
- let title_case = if cfg!(target_endian = "little") {
- !(word + 0x1f1f_1f1f_1f1f_1f3f) | (word + 0x0505_0505_0505_0525)
- } else {
- !(word + 0x3f1f_1f1f_1f1f_1f1f) | (word + 0x2505_0505_0505_0505)
- };
- (title_case & mask) == 0
- }
-
- pub const fn is_ascii_alphabetic_uppercase(&self) -> bool {
- let word = self.0;
- // See explanatory comments in is_ascii_alphabetic_lowercase
- let mask = (word + 0x7f7f_7f7f_7f7f_7f7f) & 0x8080_8080_8080_8080;
- let upper_alpha = !(word + 0x3f3f_3f3f_3f3f_3f3f) | (word + 0x2525_2525_2525_2525);
- (upper_alpha & mask) == 0
- }
-
- pub const fn to_ascii_lowercase(&self) -> Self {
- let word = self.0;
- let result = word
- | (((word + 0x3f3f_3f3f_3f3f_3f3f)
- & !(word + 0x2525_2525_2525_2525)
- & 0x8080_8080_8080_8080)
- >> 2);
- Self(result)
- }
-
- pub const fn to_ascii_titlecase(&self) -> Self {
- let word = self.0.to_le();
- let mask = ((word + 0x3f3f_3f3f_3f3f_3f1f)
- & !(word + 0x2525_2525_2525_2505)
- & 0x8080_8080_8080_8080)
- >> 2;
- let result = (word | mask) & !(0x20 & mask);
- Self(u64::from_le(result))
- }
-
- pub const fn to_ascii_uppercase(&self) -> Self {
- let word = self.0;
- let result = word
- & !(((word + 0x1f1f_1f1f_1f1f_1f1f)
- & !(word + 0x0505_0505_0505_0505)
- & 0x8080_8080_8080_8080)
- >> 2);
- Self(result)
- }
-}
diff --git a/vendor/tinystr/src/lib.rs b/vendor/tinystr/src/lib.rs
deleted file mode 100644
index 19440720..00000000
--- a/vendor/tinystr/src/lib.rs
+++ /dev/null
@@ -1,114 +0,0 @@
-// This file is part of ICU4X. For terms of use, please see the file
-// called LICENSE at the top level of the ICU4X source tree
-// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
-
-//! `tinystr` is a utility crate of the [`ICU4X`] project.
-//!
-//! It includes [`TinyAsciiStr`], a core API for representing small ASCII-only bounded length strings.
-//!
-//! It is optimized for operations on strings of size 8 or smaller. When use cases involve comparison
-//! and conversion of strings for lowercase/uppercase/titlecase, or checking
-//! numeric/alphabetic/alphanumeric, `TinyAsciiStr` is the edge performance library.
-//!
-//! # Examples
-//!
-//! ```rust
-//! use tinystr::TinyAsciiStr;
-//!
-//! let s1: TinyAsciiStr<4> = "tEsT".parse().expect("Failed to parse.");
-//!
-//! assert_eq!(s1, "tEsT");
-//! assert_eq!(s1.to_ascii_uppercase(), "TEST");
-//! assert_eq!(s1.to_ascii_lowercase(), "test");
-//! assert_eq!(s1.to_ascii_titlecase(), "Test");
-//! assert!(s1.is_ascii_alphanumeric());
-//! assert!(!s1.is_ascii_numeric());
-//!
-//! let s2 = TinyAsciiStr::<8>::try_from_raw(*b"New York")
-//! .expect("Failed to parse.");
-//!
-//! assert_eq!(s2, "New York");
-//! assert_eq!(s2.to_ascii_uppercase(), "NEW YORK");
-//! assert_eq!(s2.to_ascii_lowercase(), "new york");
-//! assert_eq!(s2.to_ascii_titlecase(), "New york");
-//! assert!(!s2.is_ascii_alphanumeric());
-//! ```
-//!
-//! # Details
-//!
-//! When strings are of size 8 or smaller, the struct transforms the strings as `u32`/`u64` and uses
-//! bitmasking to provide basic string manipulation operations:
-//! * `is_ascii_numeric`
-//! * `is_ascii_alphabetic`
-//! * `is_ascii_alphanumeric`
-//! * `to_ascii_lowercase`
-//! * `to_ascii_uppercase`
-//! * `to_ascii_titlecase`
-//! * `PartialEq`
-//!
-//! `TinyAsciiStr` will fall back to `u8` character manipulation for strings of length greater than 8.
-
-//!
-//! [`ICU4X`]: ../icu/index.html
-
-// https://github.com/unicode-org/icu4x/blob/main/documents/process/boilerplate.md#library-annotations
-#![cfg_attr(not(any(test, doc)), no_std)]
-#![cfg_attr(
- not(test),
- deny(
- clippy::indexing_slicing,
- clippy::unwrap_used,
- clippy::expect_used,
- clippy::panic,
- clippy::exhaustive_structs,
- clippy::exhaustive_enums,
- clippy::trivially_copy_pass_by_ref,
- missing_debug_implementations,
- )
-)]
-
-mod macros;
-
-mod ascii;
-mod asciibyte;
-mod error;
-mod int_ops;
-mod unvalidated;
-
-#[cfg(feature = "serde")]
-mod serde;
-
-#[cfg(feature = "databake")]
-mod databake;
-
-#[cfg(feature = "zerovec")]
-mod ule;
-
-#[cfg(any(feature = "serde", feature = "alloc"))]
-extern crate alloc;
-
-pub use ascii::TinyAsciiStr;
-pub use error::ParseError;
-pub use unvalidated::UnvalidatedTinyAsciiStr;
-
-/// These are temporary compatability reexports that will be removed
-/// in a future version.
-pub type TinyStr4 = TinyAsciiStr<4>;
-/// These are temporary compatability reexports that will be removed
-/// in a future version.
-pub type TinyStr8 = TinyAsciiStr<8>;
-/// These are temporary compatability reexports that will be removed
-/// in a future version.
-pub type TinyStr16 = TinyAsciiStr<16>;
-
-#[test]
-fn test_size() {
- assert_eq!(
- core::mem::size_of::<TinyStr4>(),
- core::mem::size_of::<Option<TinyStr4>>()
- );
- assert_eq!(
- core::mem::size_of::<TinyStr8>(),
- core::mem::size_of::<Option<TinyStr8>>()
- );
-}
diff --git a/vendor/tinystr/src/macros.rs b/vendor/tinystr/src/macros.rs
deleted file mode 100644
index 30dc445e..00000000
--- a/vendor/tinystr/src/macros.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-// This file is part of ICU4X. For terms of use, please see the file
-// called LICENSE at the top level of the ICU4X source tree
-// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
-
-#[macro_export]
-macro_rules! tinystr {
- ($n:literal, $s:literal) => {{
- // Force it into a const context; otherwise it may get evaluated at runtime instead.
- const TINYSTR_MACRO_CONST: $crate::TinyAsciiStr<$n> = {
- match $crate::TinyAsciiStr::try_from_utf8($s.as_bytes()) {
- Ok(s) => s,
- // We are okay with panicking here because this is in a const context
- #[allow(clippy::panic)]
- // Cannot format the error since formatting isn't const yet
- Err(_) => panic!(concat!("Failed to construct tinystr from ", $s)),
- }
- };
- TINYSTR_MACRO_CONST
- }};
-}
-
-#[cfg(test)]
-mod tests {
- #[test]
- fn test_macro_construction() {
- let s1 = tinystr!(8, "foobar");
- assert_eq!(&*s1, "foobar");
-
- let s1 = tinystr!(12, "foobarbaz");
- assert_eq!(&*s1, "foobarbaz");
- }
-}
diff --git a/vendor/tinystr/src/serde.rs b/vendor/tinystr/src/serde.rs
deleted file mode 100644
index 529902b5..00000000
--- a/vendor/tinystr/src/serde.rs
+++ /dev/null
@@ -1,91 +0,0 @@
-// This file is part of ICU4X. For terms of use, please see the file
-// called LICENSE at the top level of the ICU4X source tree
-// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
-
-use crate::TinyAsciiStr;
-use alloc::borrow::Cow;
-use alloc::string::ToString;
-use core::fmt;
-use core::marker::PhantomData;
-use core::ops::Deref;
-use serde::de::{Error, SeqAccess, Visitor};
-use serde::ser::SerializeTuple;
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
-
-impl<const N: usize> Serialize for TinyAsciiStr<N> {
- #[inline]
- fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
- where
- S: Serializer,
- {
- if serializer.is_human_readable() {
- self.deref().serialize(serializer)
- } else {
- let mut seq = serializer.serialize_tuple(N)?;
- for byte in self.all_bytes() {
- seq.serialize_element(byte)?;
- }
- seq.end()
- }
- }
-}
-
-struct TinyAsciiStrVisitor<const N: usize> {
- marker: PhantomData<TinyAsciiStr<N>>,
-}
-
-impl<const N: usize> TinyAsciiStrVisitor<N> {
- fn new() -> Self {
- TinyAsciiStrVisitor {
- marker: PhantomData,
- }
- }
-}
-
-impl<'de, const N: usize> Visitor<'de> for TinyAsciiStrVisitor<N> {
- type Value = TinyAsciiStr<N>;
-
- fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
- write!(formatter, "a TinyAsciiStr<{N}>")
- }
-
- #[inline]
- fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
- where
- A: SeqAccess<'de>,
- {
- let mut bytes = [0u8; N];
- let mut zeroes = false;
- for out in &mut bytes.iter_mut().take(N) {
- let byte = seq
- .next_element()?
- .ok_or_else(|| Error::invalid_length(N, &self))?;
- if byte == 0 {
- zeroes = true;
- } else if zeroes {
- return Err(Error::custom("TinyAsciiStr cannot contain null bytes"));
- }
-
- if byte >= 0x80 {
- return Err(Error::custom("TinyAsciiStr cannot contain non-ascii bytes"));
- }
- *out = byte;
- }
-
- Ok(unsafe { TinyAsciiStr::from_utf8_unchecked(bytes) })
- }
-}
-
-impl<'de, const N: usize> Deserialize<'de> for TinyAsciiStr<N> {
- fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
- where
- D: Deserializer<'de>,
- {
- if deserializer.is_human_readable() {
- let x: Cow<'de, str> = Deserialize::deserialize(deserializer)?;
- TinyAsciiStr::try_from_str(&x).map_err(|e| Error::custom(e.to_string()))
- } else {
- deserializer.deserialize_tuple(N, TinyAsciiStrVisitor::<N>::new())
- }
- }
-}
diff --git a/vendor/tinystr/src/ule.rs b/vendor/tinystr/src/ule.rs
deleted file mode 100644
index 0dd10ff7..00000000
--- a/vendor/tinystr/src/ule.rs
+++ /dev/null
@@ -1,125 +0,0 @@
-// This file is part of ICU4X. For terms of use, please see the file
-// called LICENSE at the top level of the ICU4X source tree
-// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
-
-use crate::{TinyAsciiStr, UnvalidatedTinyAsciiStr};
-#[cfg(feature = "alloc")]
-use zerovec::maps::ZeroMapKV;
-use zerovec::ule::*;
-#[cfg(feature = "alloc")]
-use zerovec::{ZeroSlice, ZeroVec};
-
-// Safety (based on the safety checklist on the ULE trait):
-// 1. TinyAsciiStr does not include any uninitialized or padding bytes.
-// (achieved by `#[repr(transparent)]` on a type that satisfies this invariant)
-// 2. TinyAsciiStr is aligned to 1 byte.
-// (achieved by `#[repr(transparent)]` on a type that satisfies this invariant)
-// 3. The impl of validate_bytes() returns an error if any byte is not valid.
-// 4. The impl of validate_bytes() returns an error if there are extra bytes.
-// 5. The other ULE methods use the default impl.
-// 6. TinyAsciiStr byte equality is semantic equality
-unsafe impl<const N: usize> ULE for TinyAsciiStr<N> {
- #[inline]
- fn validate_bytes(bytes: &[u8]) -> Result<(), UleError> {
- if bytes.len() % N != 0 {
- return Err(UleError::length::<Self>(bytes.len()));
- }
- // Validate the bytes
- for chunk in bytes.chunks_exact(N) {
- let _ = TinyAsciiStr::<N>::try_from_utf8_inner(chunk, true)
- .map_err(|_| UleError::parse::<Self>())?;
- }
- Ok(())
- }
-}
-
-impl<const N: usize> NicheBytes<N> for TinyAsciiStr<N> {
- // AsciiByte is 0..128
- const NICHE_BIT_PATTERN: [u8; N] = [255; N];
-}
-
-impl<const N: usize> AsULE for TinyAsciiStr<N> {
- type ULE = Self;
-
- #[inline]
- fn to_unaligned(self) -> Self::ULE {
- self
- }
-
- #[inline]
- fn from_unaligned(unaligned: Self::ULE) -> Self {
- unaligned
- }
-}
-
-#[cfg(feature = "alloc")]
-impl<'a, const N: usize> ZeroMapKV<'a> for TinyAsciiStr<N> {
- type Container = ZeroVec<'a, TinyAsciiStr<N>>;
- type Slice = ZeroSlice<TinyAsciiStr<N>>;
- type GetType = TinyAsciiStr<N>;
- type OwnedType = TinyAsciiStr<N>;
-}
-
-// Safety (based on the safety checklist on the ULE trait):
-// 1. UnvalidatedTinyAsciiStr does not include any uninitialized or padding bytes.
-// (achieved by `#[repr(transparent)]` on a type that satisfies this invariant)
-// 2. UnvalidatedTinyAsciiStr is aligned to 1 byte.
-// (achieved by `#[repr(transparent)]` on a type that satisfies this invariant)
-// 3. The impl of validate_bytes() returns an error if any byte is not valid.
-// 4. The impl of validate_bytes() returns an error if there are extra bytes.
-// 5. The other ULE methods use the default impl.
-// 6. UnvalidatedTinyAsciiStr byte equality is semantic equality
-unsafe impl<const N: usize> ULE for UnvalidatedTinyAsciiStr<N> {
- #[inline]
- fn validate_bytes(bytes: &[u8]) -> Result<(), UleError> {
- if bytes.len() % N != 0 {
- return Err(UleError::length::<Self>(bytes.len()));
- }
- Ok(())
- }
-}
-
-impl<const N: usize> AsULE for UnvalidatedTinyAsciiStr<N> {
- type ULE = Self;
-
- #[inline]
- fn to_unaligned(self) -> Self::ULE {
- self
- }
-
- #[inline]
- fn from_unaligned(unaligned: Self::ULE) -> Self {
- unaligned
- }
-}
-
-#[cfg(feature = "alloc")]
-impl<'a, const N: usize> ZeroMapKV<'a> for UnvalidatedTinyAsciiStr<N> {
- type Container = ZeroVec<'a, UnvalidatedTinyAsciiStr<N>>;
- type Slice = ZeroSlice<UnvalidatedTinyAsciiStr<N>>;
- type GetType = UnvalidatedTinyAsciiStr<N>;
- type OwnedType = UnvalidatedTinyAsciiStr<N>;
-}
-
-#[cfg(test)]
-mod test {
- use crate::*;
- use zerovec::*;
-
- #[test]
- fn test_zerovec() {
- let mut vec = ZeroVec::<TinyAsciiStr<7>>::new();
-
- vec.with_mut(|v| v.push("foobar".parse().unwrap()));
- vec.with_mut(|v| v.push("baz".parse().unwrap()));
- vec.with_mut(|v| v.push("quux".parse().unwrap()));
-
- let bytes = vec.as_bytes();
-
- let vec: ZeroVec<TinyAsciiStr<7>> = ZeroVec::parse_bytes(bytes).unwrap();
-
- assert_eq!(&*vec.get(0).unwrap(), "foobar");
- assert_eq!(&*vec.get(1).unwrap(), "baz");
- assert_eq!(&*vec.get(2).unwrap(), "quux");
- }
-}
diff --git a/vendor/tinystr/src/unvalidated.rs b/vendor/tinystr/src/unvalidated.rs
deleted file mode 100644
index 3758b64f..00000000
--- a/vendor/tinystr/src/unvalidated.rs
+++ /dev/null
@@ -1,122 +0,0 @@
-// This file is part of ICU4X. For terms of use, please see the file
-// called LICENSE at the top level of the ICU4X source tree
-// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
-
-use crate::ParseError;
-use crate::TinyAsciiStr;
-use core::fmt;
-
-/// A fixed-length bytes array that is expected to be an ASCII string but does not enforce that invariant.
-///
-/// Use this type instead of `TinyAsciiStr` if you don't need to enforce ASCII during deserialization. For
-/// example, strings that are keys of a map don't need to ever be reified as `TinyAsciiStr`s.
-///
-/// The main advantage of this type over `[u8; N]` is that it serializes as a string in
-/// human-readable formats like JSON.
-#[derive(PartialEq, PartialOrd, Eq, Ord, Clone, Copy)]
-pub struct UnvalidatedTinyAsciiStr<const N: usize>(pub(crate) [u8; N]);
-
-impl<const N: usize> fmt::Debug for UnvalidatedTinyAsciiStr<N> {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- // Debug as a string if possible
- match self.try_into_tinystr() {
- Ok(s) => fmt::Debug::fmt(&s, f),
- Err(_) => fmt::Debug::fmt(&self.0, f),
- }
- }
-}
-
-impl<const N: usize> UnvalidatedTinyAsciiStr<N> {
- #[inline]
- /// Converts into a [`TinyAsciiStr`]. Fails if the bytes are not valid ASCII.
- pub fn try_into_tinystr(self) -> Result<TinyAsciiStr<N>, ParseError> {
- TinyAsciiStr::try_from_raw(self.0)
- }
-
- #[inline]
- /// Unsafely converts into a [`TinyAsciiStr`].
- pub const fn from_utf8_unchecked(bytes: [u8; N]) -> Self {
- Self(bytes)
- }
-}
-
-impl<const N: usize> TinyAsciiStr<N> {
- #[inline]
- // Converts into a [`UnvalidatedTinyAsciiStr`]
- pub const fn to_unvalidated(self) -> UnvalidatedTinyAsciiStr<N> {
- UnvalidatedTinyAsciiStr(*self.all_bytes())
- }
-}
-
-impl<const N: usize> From<TinyAsciiStr<N>> for UnvalidatedTinyAsciiStr<N> {
- fn from(other: TinyAsciiStr<N>) -> Self {
- other.to_unvalidated()
- }
-}
-
-#[cfg(feature = "serde")]
-impl<const N: usize> serde::Serialize for UnvalidatedTinyAsciiStr<N> {
- fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
- where
- S: serde::Serializer,
- {
- use serde::ser::Error;
- self.try_into_tinystr()
- .map_err(|_| S::Error::custom("invalid ascii in UnvalidatedTinyAsciiStr"))?
- .serialize(serializer)
- }
-}
-
-macro_rules! deserialize {
- ($size:literal) => {
- #[cfg(feature = "serde")]
- impl<'de, 'a> serde::Deserialize<'de> for UnvalidatedTinyAsciiStr<$size>
- where
- 'de: 'a,
- {
- fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
- where
- D: serde::Deserializer<'de>,
- {
- if deserializer.is_human_readable() {
- Ok(TinyAsciiStr::deserialize(deserializer)?.to_unvalidated())
- } else {
- Ok(Self(<[u8; $size]>::deserialize(deserializer)?))
- }
- }
- }
- };
-}
-
-deserialize!(1);
-deserialize!(2);
-deserialize!(3);
-deserialize!(4);
-deserialize!(5);
-deserialize!(6);
-deserialize!(7);
-deserialize!(8);
-deserialize!(9);
-deserialize!(10);
-deserialize!(11);
-deserialize!(12);
-deserialize!(13);
-deserialize!(14);
-deserialize!(15);
-deserialize!(16);
-deserialize!(17);
-deserialize!(18);
-deserialize!(19);
-deserialize!(20);
-deserialize!(21);
-deserialize!(22);
-deserialize!(23);
-deserialize!(24);
-deserialize!(25);
-deserialize!(26);
-deserialize!(27);
-deserialize!(28);
-deserialize!(29);
-deserialize!(30);
-deserialize!(31);
-deserialize!(32);
generated by cgit v1.2.3 (git 2.39.1) at 2026-02-04 03:16:37 +0000