| // 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::TinyStrError; |
| 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> { |
| /// Creates a `TinyAsciiStr<N>` from the given byte slice. |
| /// `bytes` may contain at most `N` non-null ASCII bytes. |
| pub const fn from_bytes(bytes: &[u8]) -> Result<Self, TinyStrError> { |
| Self::from_bytes_inner(bytes, 0, bytes.len(), false) |
| } |
| |
| /// Creates a `TinyAsciiStr<N>` from a byte slice, replacing invalid bytes. |
| /// |
| /// Null and non-ASCII bytes (i.e. those outside the range `0x01..=0x7F`) |
| /// will be replaced with the '?' character. |
| /// |
| /// The input slice will be truncated if its length exceeds `N`. |
| pub const fn from_bytes_lossy(bytes: &[u8]) -> Self { |
| const QUESTION: u8 = b'?'; |
| let mut out = [0; N]; |
| let mut i = 0; |
| // Ord is not available in const, so no `.min(N)` |
| let len = if bytes.len() > N { N } else { bytes.len() }; |
| |
| // Indexing is protected by the len check above |
| #[allow(clippy::indexing_slicing)] |
| while i < len { |
| let b = bytes[i]; |
| if b > 0 && b < 0x80 { |
| out[i] = b; |
| } else { |
| out[i] = QUESTION; |
| } |
| 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, TinyStrError> { |
| Self::from_bytes_inner(&raw, 0, N, true) |
| } |
| |
| /// Equivalent to [`from_bytes(bytes[start..end])`](Self::from_bytes), |
| /// but callable in a `const` context (which range indexing is not). |
| pub const fn from_bytes_manual_slice( |
| bytes: &[u8], |
| start: usize, |
| end: usize, |
| ) -> Result<Self, TinyStrError> { |
| Self::from_bytes_inner(bytes, start, end, false) |
| } |
| |
| #[inline] |
| pub(crate) const fn from_bytes_inner( |
| bytes: &[u8], |
| start: usize, |
| end: usize, |
| allow_trailing_null: bool, |
| ) -> Result<Self, TinyStrError> { |
| let len = end - start; |
| if len > N { |
| return Err(TinyStrError::TooLarge { 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 = bytes[start + i]; |
| |
| if b == 0 { |
| found_null = true; |
| } else if b >= 0x80 { |
| return Err(TinyStrError::NonAscii); |
| } else if found_null { |
| // Error if there are contentful bytes after null |
| return Err(TinyStrError::ContainsNull); |
| } |
| out[i] = b; |
| |
| i += 1; |
| } |
| |
| if !allow_trailing_null && found_null { |
| // We found some trailing nulls, error |
| return Err(TinyStrError::ContainsNull); |
| } |
| |
| Ok(Self { |
| // SAFETY: `out` only contains ASCII bytes and has same size as `self.bytes` |
| bytes: unsafe { AsciiByte::to_ascii_byte_array(&out) }, |
| }) |
| } |
| |
| // TODO: This function shadows the FromStr trait. Rename? |
| #[inline] |
| pub const fn from_str(s: &str) -> Result<Self, TinyStrError> { |
| Self::from_bytes_inner(s.as_bytes(), 0, s.len(), false) |
| } |
| |
| #[inline] |
| pub const fn as_str(&self) -> &str { |
| // as_bytes is valid utf8 |
| unsafe { str::from_utf8_unchecked(self.as_bytes()) } |
| } |
| |
| #[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_bytes(&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_bytes_unchecked(bytes) } |
| } |
| |
| /// # 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_bytes_unchecked(bytes: [u8; N]) -> Self { |
| Self { |
| bytes: AsciiByte::to_ascii_byte_array(&bytes), |
| } |
| } |
| } |
| |
| 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> FromStr for TinyAsciiStr<N> { |
| type Err = TinyStrError; |
| #[inline] |
| fn from_str(s: &str) -> Result<Self, Self::Err> { |
| Self::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(TinyStrError::TooLarge { .. }) => 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>::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>::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>::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>::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>::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>::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_bytes_lossy(b"").as_str(), ""); |
| assert_eq!( |
| TinyAsciiStr::<4>::from_bytes_lossy(b"oh\0o").as_str(), |
| "oh?o" |
| ); |
| assert_eq!(TinyAsciiStr::<4>::from_bytes_lossy(b"\0").as_str(), "?"); |
| assert_eq!( |
| TinyAsciiStr::<4>::from_bytes_lossy(b"toolong").as_str(), |
| "tool" |
| ); |
| assert_eq!( |
| TinyAsciiStr::<4>::from_bytes_lossy(&[b'a', 0x80, 0xFF, b'1']).as_str(), |
| "a??1" |
| ); |
| } |
| } |
