diff options
Diffstat (limited to 'vendor/writeable/src')
| -rw-r--r-- | vendor/writeable/src/cmp.rs | 156 | ||||
| -rw-r--r-- | vendor/writeable/src/either.rs | 41 | ||||
| -rw-r--r-- | vendor/writeable/src/impls.rs | 262 | ||||
| -rw-r--r-- | vendor/writeable/src/lib.rs | 455 | ||||
| -rw-r--r-- | vendor/writeable/src/ops.rs | 294 | ||||
| -rw-r--r-- | vendor/writeable/src/parts_write_adapter.rs | 115 | ||||
| -rw-r--r-- | vendor/writeable/src/testing.rs | 78 | ||||
| -rw-r--r-- | vendor/writeable/src/to_string_or_borrow.rs | 210 | ||||
| -rw-r--r-- | vendor/writeable/src/try_writeable.rs | 439 |
9 files changed, 0 insertions, 2050 deletions
diff --git a/vendor/writeable/src/cmp.rs b/vendor/writeable/src/cmp.rs deleted file mode 100644 index 5f0050e2..00000000 --- a/vendor/writeable/src/cmp.rs +++ /dev/null @@ -1,156 +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::Writeable; -use core::cmp::Ordering; -use core::fmt; - -struct WriteComparator<'a> { - code_units: &'a [u8], - result: Ordering, -} - -/// This is an infallible impl. Functions always return Ok, not Err. -impl fmt::Write for WriteComparator<'_> { - #[inline] - fn write_str(&mut self, other: &str) -> fmt::Result { - if self.result != Ordering::Equal { - return Ok(()); - } - let (this, remainder) = self - .code_units - .split_at_checked(other.len()) - .unwrap_or((self.code_units, &[])); - self.code_units = remainder; - self.result = this.cmp(other.as_bytes()); - Ok(()) - } -} - -impl<'a> WriteComparator<'a> { - #[inline] - fn new(code_units: &'a [u8]) -> Self { - Self { - code_units, - result: Ordering::Equal, - } - } - - #[inline] - fn finish(self) -> Ordering { - if matches!(self.result, Ordering::Equal) && !self.code_units.is_empty() { - // Self is longer than Other - Ordering::Greater - } else { - self.result - } - } -} - -/// Compares the contents of a [`Writeable`] to the given UTF-8 bytes without allocating memory. -/// -/// For more details, see: [`cmp_str`] -pub fn cmp_utf8(writeable: &impl Writeable, other: &[u8]) -> Ordering { - let mut wc = WriteComparator::new(other); - let _ = writeable.write_to(&mut wc); - wc.finish().reverse() -} - -/// Compares the contents of a `Writeable` to the given bytes -/// without allocating a String to hold the `Writeable` contents. -/// -/// This returns a lexicographical comparison, the same as if the Writeable -/// were first converted to a String and then compared with `Ord`. For a -/// string ordering suitable for display to end users, use a localized -/// collation crate, such as `icu_collator`. -/// -/// # Examples -/// -/// ``` -/// use core::cmp::Ordering; -/// use core::fmt; -/// use writeable::Writeable; -/// -/// struct WelcomeMessage<'s> { -/// pub name: &'s str, -/// } -/// -/// impl<'s> Writeable for WelcomeMessage<'s> { -/// // see impl in Writeable docs -/// # fn write_to<W: fmt::Write + ?Sized>(&self, sink: &mut W) -> fmt::Result { -/// # sink.write_str("Hello, ")?; -/// # sink.write_str(self.name)?; -/// # sink.write_char('!')?; -/// # Ok(()) -/// # } -/// } -/// -/// let message = WelcomeMessage { name: "Alice" }; -/// let message_str = message.write_to_string(); -/// -/// assert_eq!(Ordering::Equal, writeable::cmp_str(&message, "Hello, Alice!")); -/// -/// assert_eq!(Ordering::Greater, writeable::cmp_str(&message, "Alice!")); -/// assert_eq!(Ordering::Greater, (*message_str).cmp("Alice!")); -/// -/// assert_eq!(Ordering::Less, writeable::cmp_str(&message, "Hello, Bob!")); -/// assert_eq!(Ordering::Less, (*message_str).cmp("Hello, Bob!")); -/// ``` -#[inline] -pub fn cmp_str(writeable: &impl Writeable, other: &str) -> Ordering { - cmp_utf8(writeable, other.as_bytes()) -} - -#[cfg(test)] -mod tests { - use super::*; - use core::fmt::Write; - - mod data { - include!("../tests/data/data.rs"); - } - - #[test] - fn test_write_char() { - for a in data::KEBAB_CASE_STRINGS { - for b in data::KEBAB_CASE_STRINGS { - let mut wc = WriteComparator::new(a.as_bytes()); - for ch in b.chars() { - wc.write_char(ch).unwrap(); - } - assert_eq!(a.cmp(b), wc.finish(), "{a} <=> {b}"); - } - } - } - - #[test] - fn test_write_str() { - for a in data::KEBAB_CASE_STRINGS { - for b in data::KEBAB_CASE_STRINGS { - let mut wc = WriteComparator::new(a.as_bytes()); - wc.write_str(b).unwrap(); - assert_eq!(a.cmp(b), wc.finish(), "{a} <=> {b}"); - } - } - } - - #[test] - fn test_mixed() { - for a in data::KEBAB_CASE_STRINGS { - for b in data::KEBAB_CASE_STRINGS { - let mut wc = WriteComparator::new(a.as_bytes()); - let mut first = true; - for substr in b.split('-') { - if first { - first = false; - } else { - wc.write_char('-').unwrap(); - } - wc.write_str(substr).unwrap(); - } - assert_eq!(a.cmp(b), wc.finish(), "{a} <=> {b}"); - } - } - } -} diff --git a/vendor/writeable/src/either.rs b/vendor/writeable/src/either.rs deleted file mode 100644 index 67be94f5..00000000 --- a/vendor/writeable/src/either.rs +++ /dev/null @@ -1,41 +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::*; -use ::either::Either; - -/// A [`Writeable`] impl that delegates to one type or another type. -impl<W0, W1> Writeable for Either<W0, W1> -where - W0: Writeable, - W1: Writeable, -{ - fn write_to<W: fmt::Write + ?Sized>(&self, sink: &mut W) -> fmt::Result { - match self { - Either::Left(w) => w.write_to(sink), - Either::Right(w) => w.write_to(sink), - } - } - - fn write_to_parts<S: PartsWrite + ?Sized>(&self, sink: &mut S) -> fmt::Result { - match self { - Either::Left(w) => w.write_to_parts(sink), - Either::Right(w) => w.write_to_parts(sink), - } - } - - fn writeable_length_hint(&self) -> LengthHint { - match self { - Either::Left(w) => w.writeable_length_hint(), - Either::Right(w) => w.writeable_length_hint(), - } - } - - fn write_to_string(&self) -> Cow<str> { - match self { - Either::Left(w) => w.write_to_string(), - Either::Right(w) => w.write_to_string(), - } - } -} diff --git a/vendor/writeable/src/impls.rs b/vendor/writeable/src/impls.rs deleted file mode 100644 index bf935161..00000000 --- a/vendor/writeable/src/impls.rs +++ /dev/null @@ -1,262 +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::*; -use core::fmt; - -macro_rules! impl_write_num { - ($u:ty, $i:ty, $test:ident) => { - impl $crate::Writeable for $u { - fn write_to<W: core::fmt::Write + ?Sized>(&self, sink: &mut W) -> core::fmt::Result { - const MAX_LEN: usize = <$u>::MAX.ilog10() as usize + 1; - let mut buf = [b'0'; MAX_LEN]; - let mut n = *self; - let mut i = MAX_LEN; - #[allow(clippy::indexing_slicing)] // n < 10^i - while n != 0 { - i -= 1; - buf[i] = b'0' + (n % 10) as u8; - n /= 10; - } - if i == MAX_LEN { - debug_assert_eq!(*self, 0); - i -= 1; - } - #[allow(clippy::indexing_slicing)] // buf is ASCII - let s = unsafe { core::str::from_utf8_unchecked(&buf[i..]) }; - sink.write_str(s) - } - - fn writeable_length_hint(&self) -> $crate::LengthHint { - LengthHint::exact(self.checked_ilog10().unwrap_or(0) as usize + 1) - } - } - - impl $crate::Writeable for $i { - fn write_to<W: core::fmt::Write + ?Sized>(&self, sink: &mut W) -> core::fmt::Result { - if self.is_negative() { - sink.write_str("-")?; - } - self.unsigned_abs().write_to(sink) - } - - fn writeable_length_hint(&self) -> $crate::LengthHint { - $crate::LengthHint::exact(if self.is_negative() { 1 } else { 0 }) - + self.unsigned_abs().writeable_length_hint() - } - } - - #[test] - fn $test() { - use $crate::assert_writeable_eq; - assert_writeable_eq!(&(0 as $u), "0"); - assert_writeable_eq!(&(0 as $i), "0"); - assert_writeable_eq!(&(-0 as $i), "0"); - assert_writeable_eq!(&(1 as $u), "1"); - assert_writeable_eq!(&(1 as $i), "1"); - assert_writeable_eq!(&(-1 as $i), "-1"); - assert_writeable_eq!(&(9 as $u), "9"); - assert_writeable_eq!(&(9 as $i), "9"); - assert_writeable_eq!(&(-9 as $i), "-9"); - assert_writeable_eq!(&(10 as $u), "10"); - assert_writeable_eq!(&(10 as $i), "10"); - assert_writeable_eq!(&(-10 as $i), "-10"); - assert_writeable_eq!(&(99 as $u), "99"); - assert_writeable_eq!(&(99 as $i), "99"); - assert_writeable_eq!(&(-99 as $i), "-99"); - assert_writeable_eq!(&(100 as $u), "100"); - assert_writeable_eq!(&(-100 as $i), "-100"); - assert_writeable_eq!(&<$u>::MAX, <$u>::MAX.to_string()); - assert_writeable_eq!(&<$i>::MAX, <$i>::MAX.to_string()); - assert_writeable_eq!(&<$i>::MIN, <$i>::MIN.to_string()); - - use rand::{rngs::SmallRng, Rng, SeedableRng}; - let mut rng = SmallRng::seed_from_u64(4); // chosen by fair dice roll. - // guaranteed to be random. - for _ in 0..1000 { - let rand = rng.gen::<$u>(); - assert_writeable_eq!(rand, rand.to_string()); - } - } - }; -} - -impl_write_num!(u8, i8, test_u8); -impl_write_num!(u16, i16, test_u16); -impl_write_num!(u32, i32, test_u32); -impl_write_num!(u64, i64, test_u64); -impl_write_num!(u128, i128, test_u128); -impl_write_num!(usize, isize, test_usize); - -impl Writeable for str { - #[inline] - fn write_to<W: fmt::Write + ?Sized>(&self, sink: &mut W) -> fmt::Result { - sink.write_str(self) - } - - #[inline] - fn writeable_length_hint(&self) -> LengthHint { - LengthHint::exact(self.len()) - } - - /// Returns a borrowed `str`. - /// - /// # Examples - /// - /// ``` - /// use std::borrow::Cow; - /// use writeable::Writeable; - /// - /// let cow = "foo".write_to_string(); - /// assert!(matches!(cow, Cow::Borrowed(_))); - /// ``` - #[inline] - fn write_to_string(&self) -> Cow<str> { - Cow::Borrowed(self) - } -} - -impl Writeable for String { - #[inline] - fn write_to<W: fmt::Write + ?Sized>(&self, sink: &mut W) -> fmt::Result { - sink.write_str(self) - } - - #[inline] - fn writeable_length_hint(&self) -> LengthHint { - LengthHint::exact(self.len()) - } - - #[inline] - fn write_to_string(&self) -> Cow<str> { - Cow::Borrowed(self) - } -} - -impl Writeable for char { - #[inline] - fn write_to<W: fmt::Write + ?Sized>(&self, sink: &mut W) -> fmt::Result { - sink.write_char(*self) - } - - #[inline] - fn writeable_length_hint(&self) -> LengthHint { - LengthHint::exact(self.len_utf8()) - } - - #[inline] - fn write_to_string(&self) -> Cow<str> { - let mut s = String::with_capacity(self.len_utf8()); - s.push(*self); - Cow::Owned(s) - } -} - -impl<T: Writeable + ?Sized> Writeable for &T { - #[inline] - fn write_to<W: fmt::Write + ?Sized>(&self, sink: &mut W) -> fmt::Result { - (*self).write_to(sink) - } - - #[inline] - fn write_to_parts<W: PartsWrite + ?Sized>(&self, sink: &mut W) -> fmt::Result { - (*self).write_to_parts(sink) - } - - #[inline] - fn writeable_length_hint(&self) -> LengthHint { - (*self).writeable_length_hint() - } - - #[inline] - fn write_to_string(&self) -> Cow<str> { - (*self).write_to_string() - } -} - -macro_rules! impl_write_smart_pointer { - ($ty:path, T: $extra_bound:path) => { - impl<'a, T: ?Sized + Writeable + $extra_bound> Writeable for $ty { - #[inline] - fn write_to<W: fmt::Write + ?Sized>(&self, sink: &mut W) -> fmt::Result { - core::borrow::Borrow::<T>::borrow(self).write_to(sink) - } - #[inline] - fn write_to_parts<W: PartsWrite + ?Sized>(&self, sink: &mut W) -> fmt::Result { - core::borrow::Borrow::<T>::borrow(self).write_to_parts(sink) - } - #[inline] - fn writeable_length_hint(&self) -> LengthHint { - core::borrow::Borrow::<T>::borrow(self).writeable_length_hint() - } - #[inline] - fn write_to_string(&self) -> Cow<str> { - core::borrow::Borrow::<T>::borrow(self).write_to_string() - } - } - }; - ($ty:path) => { - // Add a harmless duplicate Writeable bound - impl_write_smart_pointer!($ty, T: Writeable); - }; -} - -impl_write_smart_pointer!(Cow<'a, T>, T: alloc::borrow::ToOwned); -impl_write_smart_pointer!(alloc::boxed::Box<T>); -impl_write_smart_pointer!(alloc::rc::Rc<T>); -impl_write_smart_pointer!(alloc::sync::Arc<T>); - -#[test] -fn test_string_impls() { - fn check_writeable_slice<W: Writeable + core::fmt::Display>(writeables: &[W]) { - assert_writeable_eq!(&writeables[0], ""); - assert_writeable_eq!(&writeables[1], "abc"); - assert!(matches!(writeables[0].write_to_string(), Cow::Borrowed(_))); - assert!(matches!(writeables[1].write_to_string(), Cow::Borrowed(_))); - } - - // test str impl - let arr: &[&str] = &["", "abc"]; - check_writeable_slice(arr); - - // test String impl - let arr: &[String] = &[String::new(), "abc".to_owned()]; - check_writeable_slice(arr); - - // test char impl - let chars = ['a', 'β', '你', '😀']; - for i in 0..chars.len() { - let s = String::from(chars[i]); - assert_writeable_eq!(&chars[i], s); - for j in 0..chars.len() { - assert_eq!( - crate::cmp_str(&chars[j], &s), - chars[j].cmp(&chars[i]), - "{:?} vs {:?}", - chars[j], - chars[i] - ); - } - } - - // test Cow impl - let arr: &[Cow<str>] = &[Cow::Borrowed(""), Cow::Owned("abc".to_string())]; - check_writeable_slice(arr); - - // test Box impl - let arr: &[Box<str>] = &["".into(), "abc".into()]; - check_writeable_slice(arr); - - // test Rc impl - let arr: &[alloc::rc::Rc<str>] = &["".into(), "abc".into()]; - check_writeable_slice(arr); - - // test Arc impl - let arr: &[alloc::sync::Arc<str>] = &["".into(), "abc".into()]; - check_writeable_slice(arr); - - // test &T impl - let arr: &[&String] = &[&String::new(), &"abc".to_owned()]; - check_writeable_slice(arr); -} diff --git a/vendor/writeable/src/lib.rs b/vendor/writeable/src/lib.rs deleted file mode 100644 index 329e90a4..00000000 --- a/vendor/writeable/src/lib.rs +++ /dev/null @@ -1,455 +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 ). - -// 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, - ) -)] - -//! `writeable` is a utility crate of the [`ICU4X`] project. -//! -//! It includes [`Writeable`], a core trait representing an object that can be written to a -//! sink implementing `std::fmt::Write`. It is an alternative to `std::fmt::Display` with the -//! addition of a function indicating the number of bytes to be written. -//! -//! `Writeable` improves upon `std::fmt::Display` in two ways: -//! -//! 1. More efficient, since the sink can pre-allocate bytes. -//! 2. Smaller code, since the format machinery can be short-circuited. -//! -//! # Examples -//! -//! ``` -//! use std::fmt; -//! use writeable::assert_writeable_eq; -//! use writeable::LengthHint; -//! use writeable::Writeable; -//! -//! struct WelcomeMessage<'s> { -//! pub name: &'s str, -//! } -//! -//! impl<'s> Writeable for WelcomeMessage<'s> { -//! fn write_to<W: fmt::Write + ?Sized>(&self, sink: &mut W) -> fmt::Result { -//! sink.write_str("Hello, ")?; -//! sink.write_str(self.name)?; -//! sink.write_char('!')?; -//! Ok(()) -//! } -//! -//! fn writeable_length_hint(&self) -> LengthHint { -//! // "Hello, " + '!' + length of name -//! LengthHint::exact(8 + self.name.len()) -//! } -//! } -//! -//! let message = WelcomeMessage { name: "Alice" }; -//! assert_writeable_eq!(&message, "Hello, Alice!"); -//! -//! // Types implementing `Writeable` are recommended to also implement `fmt::Display`. -//! // This can be simply done by redirecting to the `Writeable` implementation: -//! writeable::impl_display_with_writeable!(WelcomeMessage<'_>); -//! assert_eq!(message.to_string(), "Hello, Alice!"); -//! ``` -//! -//! [`ICU4X`]: ../icu/index.html - -extern crate alloc; - -mod cmp; -#[cfg(feature = "either")] -mod either; -mod impls; -mod ops; -mod parts_write_adapter; -mod testing; -mod to_string_or_borrow; -mod try_writeable; - -use alloc::borrow::Cow; -use alloc::string::String; -use core::fmt; - -pub use cmp::{cmp_str, cmp_utf8}; -pub use to_string_or_borrow::to_string_or_borrow; -pub use try_writeable::TryWriteable; - -/// Helper types for trait impls. -pub mod adapters { - use super::*; - - pub use parts_write_adapter::CoreWriteAsPartsWrite; - pub use parts_write_adapter::WithPart; - pub use try_writeable::TryWriteableInfallibleAsWriteable; - pub use try_writeable::WriteableAsTryWriteableInfallible; - - #[derive(Debug)] - #[allow(clippy::exhaustive_structs)] // newtype - pub struct LossyWrap<T>(pub T); - - impl<T: TryWriteable> Writeable for LossyWrap<T> { - fn write_to<W: fmt::Write + ?Sized>(&self, sink: &mut W) -> fmt::Result { - let _ = self.0.try_write_to(sink)?; - Ok(()) - } - - fn writeable_length_hint(&self) -> LengthHint { - self.0.writeable_length_hint() - } - } - - impl<T: TryWriteable> fmt::Display for LossyWrap<T> { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let _ = self.0.try_write_to(f)?; - Ok(()) - } - } -} - -#[doc(hidden)] // for testing and macros -pub mod _internal { - pub use super::testing::try_writeable_to_parts_for_test; - pub use super::testing::writeable_to_parts_for_test; - pub use alloc::string::String; -} - -/// A hint to help consumers of `Writeable` pre-allocate bytes before they call -/// [`write_to`](Writeable::write_to). -/// -/// This behaves like `Iterator::size_hint`: it is a tuple where the first element is the -/// lower bound, and the second element is the upper bound. If the upper bound is `None` -/// either there is no known upper bound, or the upper bound is larger than `usize`. -/// -/// `LengthHint` implements std`::ops::{Add, Mul}` and similar traits for easy composition. -/// During computation, the lower bound will saturate at `usize::MAX`, while the upper -/// bound will become `None` if `usize::MAX` is exceeded. -#[derive(Debug, PartialEq, Eq, Copy, Clone)] -#[non_exhaustive] -pub struct LengthHint(pub usize, pub Option<usize>); - -impl LengthHint { - pub fn undefined() -> Self { - Self(0, None) - } - - /// `write_to` will use exactly n bytes. - pub fn exact(n: usize) -> Self { - Self(n, Some(n)) - } - - /// `write_to` will use at least n bytes. - pub fn at_least(n: usize) -> Self { - Self(n, None) - } - - /// `write_to` will use at most n bytes. - pub fn at_most(n: usize) -> Self { - Self(0, Some(n)) - } - - /// `write_to` will use between `n` and `m` bytes. - pub fn between(n: usize, m: usize) -> Self { - Self(Ord::min(n, m), Some(Ord::max(n, m))) - } - - /// Returns a recommendation for the number of bytes to pre-allocate. - /// If an upper bound exists, this is used, otherwise the lower bound - /// (which might be 0). - /// - /// # Examples - /// - /// ``` - /// use writeable::Writeable; - /// - /// fn pre_allocate_string(w: &impl Writeable) -> String { - /// String::with_capacity(w.writeable_length_hint().capacity()) - /// } - /// ``` - pub fn capacity(&self) -> usize { - self.1.unwrap_or(self.0) - } - - /// Returns whether the `LengthHint` indicates that the string is exactly 0 bytes long. - pub fn is_zero(&self) -> bool { - self.1 == Some(0) - } -} - -/// [`Part`]s are used as annotations for formatted strings. -/// -/// For example, a string like `Alice, Bob` could assign a `NAME` part to the -/// substrings `Alice` and `Bob`, and a `PUNCTUATION` part to `, `. This allows -/// for example to apply styling only to names. -/// -/// `Part` contains two fields, whose usage is left up to the producer of the [`Writeable`]. -/// Conventionally, the `category` field will identify the formatting logic that produces -/// the string/parts, whereas the `value` field will have semantic meaning. `NAME` and -/// `PUNCTUATION` could thus be defined as -/// ``` -/// # use writeable::Part; -/// const NAME: Part = Part { -/// category: "userlist", -/// value: "name", -/// }; -/// const PUNCTUATION: Part = Part { -/// category: "userlist", -/// value: "punctuation", -/// }; -/// ``` -/// -/// That said, consumers should not usually have to inspect `Part` internals. Instead, -/// formatters should expose the `Part`s they produces as constants. -#[derive(Clone, Copy, Debug, PartialEq)] -#[allow(clippy::exhaustive_structs)] // stable -pub struct Part { - pub category: &'static str, - pub value: &'static str, -} - -impl Part { - /// A part that should annotate error segments in [`TryWriteable`] output. - /// - /// For an example, see [`TryWriteable`]. - pub const ERROR: Part = Part { - category: "writeable", - value: "error", - }; -} - -/// A sink that supports annotating parts of the string with [`Part`]s. -pub trait PartsWrite: fmt::Write { - type SubPartsWrite: PartsWrite + ?Sized; - - /// Annotates all strings written by the closure with the given [`Part`]. - fn with_part( - &mut self, - part: Part, - f: impl FnMut(&mut Self::SubPartsWrite) -> fmt::Result, - ) -> fmt::Result; -} - -/// `Writeable` is an alternative to `std::fmt::Display` with the addition of a length function. -pub trait Writeable { - /// Writes a string to the given sink. Errors from the sink are bubbled up. - /// The default implementation delegates to `write_to_parts`, and discards any - /// `Part` annotations. - fn write_to<W: fmt::Write + ?Sized>(&self, sink: &mut W) -> fmt::Result { - self.write_to_parts(&mut parts_write_adapter::CoreWriteAsPartsWrite(sink)) - } - - /// Write bytes and `Part` annotations to the given sink. Errors from the - /// sink are bubbled up. The default implementation delegates to `write_to`, - /// and doesn't produce any `Part` annotations. - fn write_to_parts<S: PartsWrite + ?Sized>(&self, sink: &mut S) -> fmt::Result { - self.write_to(sink) - } - - /// Returns a hint for the number of UTF-8 bytes that will be written to the sink. - /// - /// Override this method if it can be computed quickly. - fn writeable_length_hint(&self) -> LengthHint { - LengthHint::undefined() - } - - /// Creates a new `String` with the data from this `Writeable`. Like `ToString`, - /// but smaller and faster. - /// - /// The default impl allocates an owned `String`. However, if it is possible to return a - /// borrowed string, overwrite this method to return a `Cow::Borrowed`. - /// - /// To remove the `Cow` wrapper, call `.into_owned()` or `.as_str()` as appropriate. - /// - /// # Examples - /// - /// Inspect a `Writeable` before writing it to the sink: - /// - /// ``` - /// use core::fmt::{Result, Write}; - /// use writeable::Writeable; - /// - /// fn write_if_ascii<W, S>(w: &W, sink: &mut S) -> Result - /// where - /// W: Writeable + ?Sized, - /// S: Write + ?Sized, - /// { - /// let s = w.write_to_string(); - /// if s.is_ascii() { - /// sink.write_str(&s) - /// } else { - /// Ok(()) - /// } - /// } - /// ``` - /// - /// Convert the `Writeable` into a fully owned `String`: - /// - /// ``` - /// use writeable::Writeable; - /// - /// fn make_string(w: &impl Writeable) -> String { - /// w.write_to_string().into_owned() - /// } - /// ``` - fn write_to_string(&self) -> Cow<str> { - let hint = self.writeable_length_hint(); - if hint.is_zero() { - return Cow::Borrowed(""); - } - let mut output = String::with_capacity(hint.capacity()); - let _ = self.write_to(&mut output); - Cow::Owned(output) - } -} - -/// Implements [`Display`](core::fmt::Display) for types that implement [`Writeable`]. -/// -/// It's recommended to do this for every [`Writeable`] type, as it will add -/// support for `core::fmt` features like [`fmt!`](std::fmt), -/// [`print!`](std::print), [`write!`](std::write), etc. -/// -/// This macro also adds a concrete `to_string` function. This function will shadow the -/// standard library `ToString`, using the more efficient writeable-based code path. -/// To add only `Display`, use the `@display` macro variant. -#[macro_export] -macro_rules! impl_display_with_writeable { - (@display, $type:ty) => { - /// This trait is implemented for compatibility with [`fmt!`](alloc::fmt). - /// To create a string, [`Writeable::write_to_string`] is usually more efficient. - impl core::fmt::Display for $type { - #[inline] - fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { - $crate::Writeable::write_to(&self, f) - } - } - }; - ($type:ty) => { - $crate::impl_display_with_writeable!(@display, $type); - impl $type { - /// Converts the given value to a `String`. - /// - /// Under the hood, this uses an efficient [`Writeable`] implementation. - /// However, in order to avoid allocating a string, it is more efficient - /// to use [`Writeable`] directly. - pub fn to_string(&self) -> $crate::_internal::String { - $crate::Writeable::write_to_string(self).into_owned() - } - } - }; -} - -/// Testing macros for types implementing [`Writeable`]. -/// -/// Arguments, in order: -/// -/// 1. The [`Writeable`] under test -/// 2. The expected string value -/// 3. [`*_parts_eq`] only: a list of parts (`[(start, end, Part)]`) -/// -/// Any remaining arguments get passed to `format!` -/// -/// The macros tests the following: -/// -/// - Equality of string content -/// - Equality of parts ([`*_parts_eq`] only) -/// - Validity of size hint -/// -/// # Examples -/// -/// ``` -/// # use writeable::Writeable; -/// # use writeable::LengthHint; -/// # use writeable::Part; -/// # use writeable::assert_writeable_eq; -/// # use writeable::assert_writeable_parts_eq; -/// # use std::fmt::{self, Write}; -/// -/// const WORD: Part = Part { -/// category: "foo", -/// value: "word", -/// }; -/// -/// struct Demo; -/// impl Writeable for Demo { -/// fn write_to_parts<S: writeable::PartsWrite + ?Sized>( -/// &self, -/// sink: &mut S, -/// ) -> fmt::Result { -/// sink.with_part(WORD, |w| w.write_str("foo")) -/// } -/// fn writeable_length_hint(&self) -> LengthHint { -/// LengthHint::exact(3) -/// } -/// } -/// -/// writeable::impl_display_with_writeable!(Demo); -/// -/// assert_writeable_eq!(&Demo, "foo"); -/// assert_writeable_eq!(&Demo, "foo", "Message: {}", "Hello World"); -/// -/// assert_writeable_parts_eq!(&Demo, "foo", [(0, 3, WORD)]); -/// assert_writeable_parts_eq!( -/// &Demo, -/// "foo", -/// [(0, 3, WORD)], -/// "Message: {}", -/// "Hello World" -/// ); -/// ``` -/// -/// [`*_parts_eq`]: assert_writeable_parts_eq -#[macro_export] -macro_rules! assert_writeable_eq { - ($actual_writeable:expr, $expected_str:expr $(,)?) => { - $crate::assert_writeable_eq!($actual_writeable, $expected_str, "") - }; - ($actual_writeable:expr, $expected_str:expr, $($arg:tt)+) => {{ - $crate::assert_writeable_eq!(@internal, $actual_writeable, $expected_str, $($arg)*); - }}; - (@internal, $actual_writeable:expr, $expected_str:expr, $($arg:tt)+) => {{ - let actual_writeable = &$actual_writeable; - let (actual_str, actual_parts) = $crate::_internal::writeable_to_parts_for_test(actual_writeable); - let actual_len = actual_str.len(); - assert_eq!(actual_str, $expected_str, $($arg)*); - assert_eq!(actual_str, $crate::Writeable::write_to_string(actual_writeable), $($arg)+); - let length_hint = $crate::Writeable::writeable_length_hint(actual_writeable); - let lower = length_hint.0; - assert!( - lower <= actual_len, - "hint lower bound {lower} larger than actual length {actual_len}: {}", - format!($($arg)*), - ); - if let Some(upper) = length_hint.1 { - assert!( - actual_len <= upper, - "hint upper bound {upper} smaller than actual length {actual_len}: {}", - format!($($arg)*), - ); - } - assert_eq!(actual_writeable.to_string(), $expected_str); - actual_parts // return for assert_writeable_parts_eq - }}; -} - -/// See [`assert_writeable_eq`]. -#[macro_export] -macro_rules! assert_writeable_parts_eq { - ($actual_writeable:expr, $expected_str:expr, $expected_parts:expr $(,)?) => { - $crate::assert_writeable_parts_eq!($actual_writeable, $expected_str, $expected_parts, "") - }; - ($actual_writeable:expr, $expected_str:expr, $expected_parts:expr, $($arg:tt)+) => {{ - let actual_parts = $crate::assert_writeable_eq!(@internal, $actual_writeable, $expected_str, $($arg)*); - assert_eq!(actual_parts, $expected_parts, $($arg)+); - }}; -} diff --git a/vendor/writeable/src/ops.rs b/vendor/writeable/src/ops.rs deleted file mode 100644 index a4c1ffd7..00000000 --- a/vendor/writeable/src/ops.rs +++ /dev/null @@ -1,294 +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::LengthHint; - -impl core::ops::Add<LengthHint> for LengthHint { - type Output = Self; - - fn add(self, other: LengthHint) -> Self { - LengthHint( - self.0.saturating_add(other.0), - match (self.1, other.1) { - (Some(c), Some(d)) => c.checked_add(d), - _ => None, - }, - ) - } -} - -impl core::ops::AddAssign<LengthHint> for LengthHint { - fn add_assign(&mut self, other: Self) { - *self = *self + other; - } -} - -impl core::iter::Sum<LengthHint> for LengthHint { - fn sum<I>(iter: I) -> Self - where - I: Iterator<Item = LengthHint>, - { - iter.fold(LengthHint::exact(0), core::ops::Add::add) - } -} - -impl core::ops::Add<usize> for LengthHint { - type Output = Self; - - fn add(self, other: usize) -> Self { - Self( - self.0.saturating_add(other), - self.1.and_then(|upper| upper.checked_add(other)), - ) - } -} - -impl core::ops::AddAssign<usize> for LengthHint { - fn add_assign(&mut self, other: usize) { - *self = *self + other; - } -} - -impl core::ops::Mul<usize> for LengthHint { - type Output = Self; - - fn mul(self, other: usize) -> Self { - Self( - self.0.saturating_mul(other), - self.1.and_then(|upper| upper.checked_mul(other)), - ) - } -} - -impl core::ops::MulAssign<usize> for LengthHint { - fn mul_assign(&mut self, other: usize) { - *self = *self * other; - } -} - -impl core::ops::BitOr<LengthHint> for LengthHint { - type Output = Self; - - /// Returns a new hint that is correct wherever `self` is correct, and wherever - /// `other` is correct. - /// - /// Example: - /// ``` - /// # use writeable::{LengthHint, Writeable}; - /// # use core::fmt; - /// # fn coin_flip() -> bool { true } - /// - /// struct NonDeterministicWriteable(String, String); - /// - /// impl Writeable for NonDeterministicWriteable { - /// fn write_to<W: fmt::Write + ?Sized>( - /// &self, - /// sink: &mut W, - /// ) -> fmt::Result { - /// sink.write_str(if coin_flip() { &self.0 } else { &self.1 }) - /// } - /// - /// fn writeable_length_hint(&self) -> LengthHint { - /// LengthHint::exact(self.0.len()) | LengthHint::exact(self.1.len()) - /// } - /// } - /// - /// writeable::impl_display_with_writeable!(NonDeterministicWriteable); - /// ``` - fn bitor(self, other: LengthHint) -> Self { - LengthHint( - Ord::min(self.0, other.0), - match (self.1, other.1) { - (Some(c), Some(d)) => Some(Ord::max(c, d)), - _ => None, - }, - ) - } -} - -impl core::ops::BitOrAssign<LengthHint> for LengthHint { - fn bitor_assign(&mut self, other: Self) { - *self = *self | other; - } -} - -impl core::iter::Sum<usize> for LengthHint { - fn sum<I>(iter: I) -> Self - where - I: Iterator<Item = usize>, - { - LengthHint::exact(iter.sum::<usize>()) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_add() { - assert_eq!(LengthHint::exact(3) + 2, LengthHint::exact(5)); - assert_eq!( - LengthHint::exact(3) + LengthHint::exact(2), - LengthHint::exact(5) - ); - assert_eq!( - LengthHint::exact(3) + LengthHint::undefined(), - LengthHint::at_least(3) - ); - - assert_eq!(LengthHint::undefined() + 2, LengthHint::at_least(2)); - assert_eq!( - LengthHint::undefined() + LengthHint::exact(2), - LengthHint::at_least(2) - ); - assert_eq!( - LengthHint::undefined() + LengthHint::undefined(), - LengthHint::undefined() - ); - - assert_eq!( - LengthHint::at_least(15) + LengthHint::exact(3), - LengthHint::at_least(18) - ); - - assert_eq!( - LengthHint::at_least(15) + LengthHint::at_most(3), - LengthHint::at_least(15) - ); - - assert_eq!(LengthHint::between(48, 92) + 5, LengthHint::between(53, 97)); - - let mut len = LengthHint::exact(5); - len += LengthHint::exact(3); - assert_eq!(len, LengthHint::exact(8)); - len += 2; - assert_eq!(len, LengthHint::exact(10)); - len += LengthHint::undefined(); - assert_eq!(len, LengthHint::at_least(10)); - - len += LengthHint::exact(3); - assert_eq!(len, LengthHint::at_least(13)); - len += 2; - assert_eq!(len, LengthHint::at_least(15)); - len += LengthHint::undefined(); - assert_eq!(len, LengthHint::at_least(15)); - - assert_eq!( - LengthHint::between(usize::MAX - 10, usize::MAX - 5) + LengthHint::exact(20), - LengthHint::at_least(usize::MAX) - ); - } - - #[test] - fn test_sum() { - let lens = [ - LengthHint::exact(4), - LengthHint::exact(1), - LengthHint::exact(1), - ]; - assert_eq!( - lens.iter().copied().sum::<LengthHint>(), - LengthHint::exact(6) - ); - - let lens = [ - LengthHint::exact(4), - LengthHint::undefined(), - LengthHint::at_least(1), - ]; - assert_eq!( - lens.iter().copied().sum::<LengthHint>(), - LengthHint::at_least(5) - ); - - let lens = [ - LengthHint::exact(4), - LengthHint::undefined(), - LengthHint::at_most(1), - ]; - assert_eq!( - lens.iter().copied().sum::<LengthHint>(), - LengthHint::at_least(4) - ); - - let lens = [4, 1, 1]; - assert_eq!( - lens.iter().copied().sum::<LengthHint>(), - LengthHint::exact(6) - ); - } - - #[test] - fn test_mul() { - assert_eq!(LengthHint::exact(3) * 2, LengthHint::exact(6)); - - assert_eq!(LengthHint::undefined() * 2, LengthHint::undefined()); - - assert_eq!( - LengthHint::between(48, 92) * 2, - LengthHint::between(96, 184) - ); - - let mut len = LengthHint::exact(5); - len *= 2; - assert_eq!(len, LengthHint::exact(10)); - - assert_eq!( - LengthHint::between(usize::MAX - 10, usize::MAX - 5) * 2, - LengthHint::at_least(usize::MAX) - ); - } - - #[test] - fn test_bitor() { - assert_eq!( - LengthHint::exact(3) | LengthHint::exact(2), - LengthHint::between(2, 3) - ); - assert_eq!( - LengthHint::exact(3) | LengthHint::undefined(), - LengthHint::undefined() - ); - - assert_eq!( - LengthHint::undefined() | LengthHint::undefined(), - LengthHint::undefined() - ); - - assert_eq!( - LengthHint::exact(10) | LengthHint::exact(10), - LengthHint::exact(10) - ); - - assert_eq!( - LengthHint::at_least(15) | LengthHint::exact(3), - LengthHint::at_least(3) - ); - - assert_eq!( - LengthHint::at_least(15) | LengthHint::at_most(18), - LengthHint::undefined() - ); - - assert_eq!( - LengthHint::at_least(15) | LengthHint::at_least(18), - LengthHint::at_least(15) - ); - - assert_eq!( - LengthHint::at_most(15) | LengthHint::at_most(18), - LengthHint::at_most(18) - ); - - assert_eq!( - LengthHint::between(5, 10) | LengthHint::at_most(3), - LengthHint::at_most(10) - ); - - let mut len = LengthHint::exact(5); - len |= LengthHint::exact(3); - assert_eq!(len, LengthHint::between(5, 3)); - } -} diff --git a/vendor/writeable/src/parts_write_adapter.rs b/vendor/writeable/src/parts_write_adapter.rs deleted file mode 100644 index eacf3a2c..00000000 --- a/vendor/writeable/src/parts_write_adapter.rs +++ /dev/null @@ -1,115 +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::*; - -/// A wrapper around a type implementing [`fmt::Write`] that implements [`PartsWrite`]. -#[derive(Debug)] -#[allow(clippy::exhaustive_structs)] // newtype -pub struct CoreWriteAsPartsWrite<W: fmt::Write + ?Sized>(pub W); - -impl<W: fmt::Write + ?Sized> fmt::Write for CoreWriteAsPartsWrite<W> { - #[inline] - fn write_str(&mut self, s: &str) -> fmt::Result { - self.0.write_str(s) - } - - #[inline] - fn write_char(&mut self, c: char) -> fmt::Result { - self.0.write_char(c) - } -} - -impl<W: fmt::Write + ?Sized> PartsWrite for CoreWriteAsPartsWrite<W> { - type SubPartsWrite = CoreWriteAsPartsWrite<W>; - - #[inline] - fn with_part( - &mut self, - _part: Part, - mut f: impl FnMut(&mut Self::SubPartsWrite) -> fmt::Result, - ) -> fmt::Result { - f(self) - } -} - -/// A [`Writeable`] that writes out the given part. -/// -/// # Examples -/// -/// ``` -/// use writeable::adapters::WithPart; -/// use writeable::assert_writeable_parts_eq; -/// use writeable::Part; -/// -/// // Simple usage: -/// -/// const PART: Part = Part { -/// category: "foo", -/// value: "bar", -/// }; -/// -/// assert_writeable_parts_eq!( -/// WithPart { -/// writeable: "Hello World", -/// part: PART -/// }, -/// "Hello World", -/// [(0, 11, PART)], -/// ); -/// -/// // Can be nested: -/// -/// const PART2: Part = Part { -/// category: "foo2", -/// value: "bar2", -/// }; -/// -/// assert_writeable_parts_eq!( -/// WithPart { -/// writeable: WithPart { -/// writeable: "Hello World", -/// part: PART -/// }, -/// part: PART2 -/// }, -/// "Hello World", -/// [(0, 11, PART), (0, 11, PART2)], -/// ); -/// ``` -#[derive(Debug)] -#[allow(clippy::exhaustive_structs)] // public adapter -pub struct WithPart<T: ?Sized> { - pub part: Part, - pub writeable: T, -} - -impl<T: Writeable + ?Sized> Writeable for WithPart<T> { - #[inline] - fn write_to<W: fmt::Write + ?Sized>(&self, sink: &mut W) -> fmt::Result { - self.writeable.write_to(sink) - } - - #[inline] - fn write_to_parts<W: PartsWrite + ?Sized>(&self, sink: &mut W) -> fmt::Result { - sink.with_part(self.part, |w| self.writeable.write_to_parts(w)) - } - - #[inline] - fn writeable_length_hint(&self) -> LengthHint { - self.writeable.writeable_length_hint() - } - - #[inline] - fn write_to_string(&self) -> Cow<str> { - self.writeable.write_to_string() - } -} - -impl<T: Writeable + ?Sized> fmt::Display for WithPart<T> { - #[inline] - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - Writeable::write_to(&self, f) - } -} diff --git a/vendor/writeable/src/testing.rs b/vendor/writeable/src/testing.rs deleted file mode 100644 index 078ea9e2..00000000 --- a/vendor/writeable/src/testing.rs +++ /dev/null @@ -1,78 +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::*; -use alloc::string::String; -use alloc::vec::Vec; - -pub(crate) struct TestWriter { - pub(crate) string: String, - pub(crate) parts: Vec<(usize, usize, Part)>, -} - -impl TestWriter { - pub(crate) fn finish(mut self) -> (String, Vec<(usize, usize, Part)>) { - // Sort by first open and last closed - self.parts - .sort_unstable_by_key(|(begin, end, _)| (*begin, end.wrapping_neg())); - (self.string, self.parts) - } -} - -impl fmt::Write for TestWriter { - fn write_str(&mut self, s: &str) -> fmt::Result { - self.string.write_str(s) - } - fn write_char(&mut self, c: char) -> fmt::Result { - self.string.write_char(c) - } -} - -impl PartsWrite for TestWriter { - type SubPartsWrite = Self; - fn with_part( - &mut self, - part: Part, - mut f: impl FnMut(&mut Self::SubPartsWrite) -> fmt::Result, - ) -> fmt::Result { - let start = self.string.len(); - f(self)?; - let end = self.string.len(); - if start < end { - self.parts.push((start, end, part)); - } - Ok(()) - } -} - -#[allow(clippy::type_complexity)] -pub fn writeable_to_parts_for_test<W: Writeable>( - writeable: &W, -) -> (String, Vec<(usize, usize, Part)>) { - let mut writer = TestWriter { - string: alloc::string::String::new(), - parts: Vec::new(), - }; - #[allow(clippy::expect_used)] // for test code - writeable - .write_to_parts(&mut writer) - .expect("String writer infallible"); - writer.finish() -} - -#[allow(clippy::type_complexity)] -pub fn try_writeable_to_parts_for_test<W: TryWriteable>( - writeable: &W, -) -> (String, Vec<(usize, usize, Part)>, Option<W::Error>) { - let mut writer = TestWriter { - string: alloc::string::String::new(), - parts: Vec::new(), - }; - #[allow(clippy::expect_used)] // for test code - let result = writeable - .try_write_to_parts(&mut writer) - .expect("String writer infallible"); - let (actual_str, actual_parts) = writer.finish(); - (actual_str, actual_parts, result.err()) -} diff --git a/vendor/writeable/src/to_string_or_borrow.rs b/vendor/writeable/src/to_string_or_borrow.rs deleted file mode 100644 index c1eb4236..00000000 --- a/vendor/writeable/src/to_string_or_borrow.rs +++ /dev/null @@ -1,210 +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::Writeable; -use alloc::borrow::Cow; -use alloc::string::String; -use core::fmt; - -/// Bytes that have been partially validated as UTF-8 up to an offset. -struct PartiallyValidatedUtf8<'a> { - // Safety Invariants: - // 1. The offset is less than or equal to the length of the slice. - // 2. The slice is valid UTF-8 up to the offset. - slice: &'a [u8], - offset: usize, -} - -impl<'a> PartiallyValidatedUtf8<'a> { - fn new(slice: &'a [u8]) -> Self { - // Safety: Field invariants maintained here trivially: - // 1. The offset 0 is ≤ all possible lengths of slice - // 2. The slice contains nothing up to the offset zero - Self { slice, offset: 0 } - } - - /// Check whether the given string is the next chunk of unvalidated bytes. - /// If so, increment offset and return true. Otherwise, return false. - fn try_push(&mut self, valid_str: &str) -> bool { - let new_offset = self.offset + valid_str.len(); - if self.slice.get(self.offset..new_offset) == Some(valid_str.as_bytes()) { - // Safety: Field invariants maintained here: - // 1. In the line above, `self.slice.get()` returned `Some()` for `new_offset` at - // the end of a `Range`, so `new_offset` is ≤ the length of `self.slice`. - // 2. By invariant, we have already validated the string up to `self.offset`, and - // the portion of the slice between `self.offset` and `new_offset` is equal to - // `valid_str`, which is a `&str`, so the string is valid up to `new_offset`. - self.offset = new_offset; - true - } else { - false - } - } - - /// Return the validated portion as `&str`. - fn validated_as_str(&self) -> &'a str { - debug_assert!(self.offset <= self.slice.len()); - // Safety: self.offset is a valid end index in a range (from field invariant) - let valid_slice = unsafe { self.slice.get_unchecked(..self.offset) }; - debug_assert!(core::str::from_utf8(valid_slice).is_ok()); - // Safety: the UTF-8 of slice has been validated up to offset (from field invariant) - unsafe { core::str::from_utf8_unchecked(valid_slice) } - } -} - -enum SliceOrString<'a> { - Slice(PartiallyValidatedUtf8<'a>), - String(String), -} - -/// This is an infallible impl. Functions always return Ok, not Err. -impl fmt::Write for SliceOrString<'_> { - #[inline] - fn write_str(&mut self, other: &str) -> fmt::Result { - match self { - SliceOrString::Slice(slice) => { - if !slice.try_push(other) { - // We failed to match. Convert to owned. - let valid_str = slice.validated_as_str(); - let mut owned = String::with_capacity(valid_str.len() + other.len()); - owned.push_str(valid_str); - owned.push_str(other); - *self = SliceOrString::String(owned); - } - Ok(()) - } - SliceOrString::String(owned) => owned.write_str(other), - } - } -} - -impl<'a> SliceOrString<'a> { - #[inline] - fn new(slice: &'a [u8]) -> Self { - Self::Slice(PartiallyValidatedUtf8::new(slice)) - } - - #[inline] - fn finish(self) -> Cow<'a, str> { - match self { - SliceOrString::Slice(slice) => Cow::Borrowed(slice.validated_as_str()), - SliceOrString::String(owned) => Cow::Owned(owned), - } - } -} - -/// Writes the contents of a `Writeable` to a string, returning a reference -/// to a slice if it matches the provided reference bytes, and allocating a -/// String otherwise. -/// -/// This function is useful if you have borrowed bytes which you expect -/// to be equal to a writeable a high percentage of the time. -/// -/// You can also use this function to make a more efficient implementation of -/// [`Writeable::write_to_string`]. -/// -/// # Examples -/// -/// Basic usage and behavior: -/// -/// ``` -/// use std::fmt; -/// use std::borrow::Cow; -/// use writeable::Writeable; -/// -/// struct WelcomeMessage<'s> { -/// pub name: &'s str, -/// } -/// -/// impl<'s> Writeable for WelcomeMessage<'s> { -/// // see impl in Writeable docs -/// # fn write_to<W: fmt::Write + ?Sized>(&self, sink: &mut W) -> fmt::Result { -/// # sink.write_str("Hello, ")?; -/// # sink.write_str(self.name)?; -/// # sink.write_char('!')?; -/// # Ok(()) -/// # } -/// } -/// -/// let message = WelcomeMessage { name: "Alice" }; -/// -/// assert!(matches!( -/// writeable::to_string_or_borrow(&message, b""), -/// Cow::Owned(s) if s == "Hello, Alice!" -/// )); -/// assert!(matches!( -/// writeable::to_string_or_borrow(&message, b"Hello"), -/// Cow::Owned(s) if s == "Hello, Alice!" -/// )); -/// assert!(matches!( -/// writeable::to_string_or_borrow(&message, b"Hello, Bob!"), -/// Cow::Owned(s) if s == "Hello, Alice!" -/// )); -/// assert!(matches!( -/// writeable::to_string_or_borrow(&message, b"Hello, Alice!"), -/// Cow::Borrowed("Hello, Alice!") -/// )); -/// -/// // Borrowing can use a prefix: -/// assert!(matches!( -/// writeable::to_string_or_borrow(&message, b"Hello, Alice!..\xFF\x00\xFF"), -/// Cow::Borrowed("Hello, Alice!") -/// )); -/// ``` -/// -/// Example use case: a function that transforms a string to lowercase. -/// We are also able to write a more efficient implementation of -/// [`Writeable::write_to_string`] in this situation. -/// -/// ``` -/// use std::fmt; -/// use std::borrow::Cow; -/// use writeable::Writeable; -/// -/// struct MakeAsciiLower<'a>(&'a str); -/// -/// impl<'a> Writeable for MakeAsciiLower<'a> { -/// fn write_to<W: fmt::Write + ?Sized>(&self, sink: &mut W) -> fmt::Result { -/// for c in self.0.chars() { -/// sink.write_char(c.to_ascii_lowercase())?; -/// } -/// Ok(()) -/// } -/// #[inline] -/// fn write_to_string(&self) -> Cow<str> { -/// writeable::to_string_or_borrow(self, self.0.as_bytes()) -/// } -/// } -/// -/// fn make_lowercase(input: &str) -> Cow<str> { -/// let writeable = MakeAsciiLower(input); -/// writeable::to_string_or_borrow(&writeable, input.as_bytes()) -/// } -/// -/// assert!(matches!( -/// make_lowercase("this is lowercase"), -/// Cow::Borrowed("this is lowercase") -/// )); -/// assert!(matches!( -/// make_lowercase("this is UPPERCASE"), -/// Cow::Owned(s) if s == "this is uppercase" -/// )); -/// -/// assert!(matches!( -/// MakeAsciiLower("this is lowercase").write_to_string(), -/// Cow::Borrowed("this is lowercase") -/// )); -/// assert!(matches!( -/// MakeAsciiLower("this is UPPERCASE").write_to_string(), -/// Cow::Owned(s) if s == "this is uppercase" -/// )); -/// ``` -pub fn to_string_or_borrow<'a>( - writeable: &impl Writeable, - reference_bytes: &'a [u8], -) -> Cow<'a, str> { - let mut sink = SliceOrString::new(reference_bytes); - let _ = writeable.write_to(&mut sink); - sink.finish() -} diff --git a/vendor/writeable/src/try_writeable.rs b/vendor/writeable/src/try_writeable.rs deleted file mode 100644 index aa918bbd..00000000 --- a/vendor/writeable/src/try_writeable.rs +++ /dev/null @@ -1,439 +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 super::*; -use crate::parts_write_adapter::CoreWriteAsPartsWrite; -use core::convert::Infallible; - -/// A writeable object that can fail while writing. -/// -/// The default [`Writeable`] trait returns a [`fmt::Error`], which originates from the sink. -/// In contrast, this trait allows the _writeable itself_ to trigger an error as well. -/// -/// Implementations are expected to always make a _best attempt_ at writing to the sink -/// and should write replacement values in the error state. Therefore, the returned `Result` -/// can be safely ignored to emulate a "lossy" mode. -/// -/// Any error substrings should be annotated with [`Part::ERROR`]. -/// -/// # Implementer Notes -/// -/// This trait requires that implementers make a _best attempt_ at writing to the sink, -/// _even in the error state_, such as with a placeholder or fallback string. -/// -/// In [`TryWriteable::try_write_to_parts()`], error substrings should be annotated with -/// [`Part::ERROR`]. Because of this, writing to parts is not default-implemented like -/// it is on [`Writeable`]. -/// -/// The trait is implemented on [`Result<T, E>`] where `T` and `E` both implement [`Writeable`]; -/// In the `Ok` case, `T` is written, and in the `Err` case, `E` is written as a fallback value. -/// This impl, which writes [`Part::ERROR`], can be used as a basis for more advanced impls. -/// -/// # Examples -/// -/// Implementing on a custom type: -/// -/// ``` -/// use core::fmt; -/// use writeable::LengthHint; -/// use writeable::PartsWrite; -/// use writeable::TryWriteable; -/// -/// #[derive(Debug, PartialEq, Eq)] -/// enum HelloWorldWriteableError { -/// MissingName, -/// } -/// -/// #[derive(Debug, PartialEq, Eq)] -/// struct HelloWorldWriteable { -/// pub name: Option<&'static str>, -/// } -/// -/// impl TryWriteable for HelloWorldWriteable { -/// type Error = HelloWorldWriteableError; -/// -/// fn try_write_to_parts<S: PartsWrite + ?Sized>( -/// &self, -/// sink: &mut S, -/// ) -> Result<Result<(), Self::Error>, fmt::Error> { -/// sink.write_str("Hello, ")?; -/// // Use `impl TryWriteable for Result` to generate the error part: -/// let err = self.name.ok_or("nobody").try_write_to_parts(sink)?.err(); -/// sink.write_char('!')?; -/// // Return a doubly-wrapped Result. -/// // The outer Result is for fmt::Error, handled by the `?`s above. -/// // The inner Result is for our own Self::Error. -/// if err.is_none() { -/// Ok(Ok(())) -/// } else { -/// Ok(Err(HelloWorldWriteableError::MissingName)) -/// } -/// } -/// -/// fn writeable_length_hint(&self) -> LengthHint { -/// self.name.ok_or("nobody").writeable_length_hint() + 8 -/// } -/// } -/// -/// // Success case: -/// writeable::assert_try_writeable_eq!( -/// HelloWorldWriteable { -/// name: Some("Alice") -/// }, -/// "Hello, Alice!" -/// ); -/// -/// // Failure case, including the ERROR part: -/// writeable::assert_try_writeable_parts_eq!( -/// HelloWorldWriteable { name: None }, -/// "Hello, nobody!", -/// Err(HelloWorldWriteableError::MissingName), -/// [(7, 13, writeable::Part::ERROR)] -/// ); -/// ``` -pub trait TryWriteable { - type Error; - - /// Writes the content of this writeable to a sink. - /// - /// If the sink hits an error, writing immediately ends, - /// `Err(`[`fmt::Error`]`)` is returned, and the sink does not contain valid output. - /// - /// If the writeable hits an error, writing is continued with a replacement value, - /// `Ok(Err(`[`TryWriteable::Error`]`))` is returned, and the caller may continue using the sink. - /// - /// # Lossy Mode - /// - /// The [`fmt::Error`] should always be handled, but the [`TryWriteable::Error`] can be - /// ignored if a fallback string is desired instead of an error. - /// - /// To handle the sink error, but not the writeable error, write: - /// - /// ``` - /// # use writeable::TryWriteable; - /// # let my_writeable: Result<&str, &str> = Ok(""); - /// # let mut sink = String::new(); - /// let _ = my_writeable.try_write_to(&mut sink)?; - /// # Ok::<(), core::fmt::Error>(()) - /// ``` - /// - /// # Examples - /// - /// The following examples use `Result<&str, usize>`, which implements [`TryWriteable`] because both `&str` and `usize` do. - /// - /// Success case: - /// - /// ``` - /// use writeable::TryWriteable; - /// - /// let w: Result<&str, usize> = Ok("success"); - /// let mut sink = String::new(); - /// let result = w.try_write_to(&mut sink); - /// - /// assert_eq!(result, Ok(Ok(()))); - /// assert_eq!(sink, "success"); - /// ``` - /// - /// Failure case: - /// - /// ``` - /// use writeable::TryWriteable; - /// - /// let w: Result<&str, usize> = Err(44); - /// let mut sink = String::new(); - /// let result = w.try_write_to(&mut sink); - /// - /// assert_eq!(result, Ok(Err(44))); - /// assert_eq!(sink, "44"); - /// ``` - fn try_write_to<W: fmt::Write + ?Sized>( - &self, - sink: &mut W, - ) -> Result<Result<(), Self::Error>, fmt::Error> { - self.try_write_to_parts(&mut CoreWriteAsPartsWrite(sink)) - } - - /// Writes the content of this writeable to a sink with parts (annotations). - /// - /// For more information, see: - /// - /// - [`TryWriteable::try_write_to()`] for the general behavior. - /// - [`TryWriteable`] for an example with parts. - /// - [`Part`] for more about parts. - fn try_write_to_parts<S: PartsWrite + ?Sized>( - &self, - sink: &mut S, - ) -> Result<Result<(), Self::Error>, fmt::Error>; - - /// Returns a hint for the number of UTF-8 bytes that will be written to the sink. - /// - /// This function returns the length of the "lossy mode" string; for more information, - /// see [`TryWriteable::try_write_to()`]. - fn writeable_length_hint(&self) -> LengthHint { - LengthHint::undefined() - } - - /// Writes the content of this writeable to a string. - /// - /// In the failure case, this function returns the error and the best-effort string ("lossy mode"). - /// - /// Examples - /// - /// ``` - /// # use std::borrow::Cow; - /// # use writeable::TryWriteable; - /// // use the best-effort string - /// let r1: Cow<str> = Ok::<&str, u8>("ok") - /// .try_write_to_string() - /// .unwrap_or_else(|(_, s)| s); - /// // propagate the error - /// let r2: Result<Cow<str>, u8> = Ok::<&str, u8>("ok") - /// .try_write_to_string() - /// .map_err(|(e, _)| e); - /// ``` - fn try_write_to_string(&self) -> Result<Cow<str>, (Self::Error, Cow<str>)> { - let hint = self.writeable_length_hint(); - if hint.is_zero() { - return Ok(Cow::Borrowed("")); - } - let mut output = String::with_capacity(hint.capacity()); - match self - .try_write_to(&mut output) - .unwrap_or_else(|fmt::Error| Ok(())) - { - Ok(()) => Ok(Cow::Owned(output)), - Err(e) => Err((e, Cow::Owned(output))), - } - } -} - -impl<T, E> TryWriteable for Result<T, E> -where - T: Writeable, - E: Writeable + Clone, -{ - type Error = E; - - #[inline] - fn try_write_to<W: fmt::Write + ?Sized>( - &self, - sink: &mut W, - ) -> Result<Result<(), Self::Error>, fmt::Error> { - match self { - Ok(t) => t.write_to(sink).map(Ok), - Err(e) => e.write_to(sink).map(|()| Err(e.clone())), - } - } - - #[inline] - fn try_write_to_parts<S: PartsWrite + ?Sized>( - &self, - sink: &mut S, - ) -> Result<Result<(), Self::Error>, fmt::Error> { - match self { - Ok(t) => t.write_to_parts(sink).map(Ok), - Err(e) => sink - .with_part(Part::ERROR, |sink| e.write_to_parts(sink)) - .map(|()| Err(e.clone())), - } - } - - #[inline] - fn writeable_length_hint(&self) -> LengthHint { - match self { - Ok(t) => t.writeable_length_hint(), - Err(e) => e.writeable_length_hint(), - } - } - - #[inline] - fn try_write_to_string(&self) -> Result<Cow<str>, (Self::Error, Cow<str>)> { - match self { - Ok(t) => Ok(t.write_to_string()), - Err(e) => Err((e.clone(), e.write_to_string())), - } - } -} - -/// A wrapper around [`TryWriteable`] that implements [`Writeable`] -/// if [`TryWriteable::Error`] is [`Infallible`]. -#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] -#[repr(transparent)] -#[allow(clippy::exhaustive_structs)] // transparent newtype -pub struct TryWriteableInfallibleAsWriteable<T>(pub T); - -impl<T> Writeable for TryWriteableInfallibleAsWriteable<T> -where - T: TryWriteable<Error = Infallible>, -{ - #[inline] - fn write_to<W: fmt::Write + ?Sized>(&self, sink: &mut W) -> fmt::Result { - match self.0.try_write_to(sink) { - Ok(Ok(())) => Ok(()), - Ok(Err(infallible)) => match infallible {}, - Err(e) => Err(e), - } - } - - #[inline] - fn write_to_parts<S: PartsWrite + ?Sized>(&self, sink: &mut S) -> fmt::Result { - match self.0.try_write_to_parts(sink) { - Ok(Ok(())) => Ok(()), - Ok(Err(infallible)) => match infallible {}, - Err(e) => Err(e), - } - } - - #[inline] - fn writeable_length_hint(&self) -> LengthHint { - self.0.writeable_length_hint() - } - - #[inline] - fn write_to_string(&self) -> Cow<str> { - match self.0.try_write_to_string() { - Ok(s) => s, - Err((infallible, _)) => match infallible {}, - } - } -} - -impl<T> fmt::Display for TryWriteableInfallibleAsWriteable<T> -where - T: TryWriteable<Error = Infallible>, -{ - #[inline] - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - self.write_to(f) - } -} - -/// A wrapper around [`Writeable`] that implements [`TryWriteable`] -/// with [`TryWriteable::Error`] set to [`Infallible`]. -#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] -#[repr(transparent)] -#[allow(clippy::exhaustive_structs)] // transparent newtype -pub struct WriteableAsTryWriteableInfallible<T>(pub T); - -impl<T> TryWriteable for WriteableAsTryWriteableInfallible<T> -where - T: Writeable, -{ - type Error = Infallible; - - #[inline] - fn try_write_to<W: fmt::Write + ?Sized>( - &self, - sink: &mut W, - ) -> Result<Result<(), Infallible>, fmt::Error> { - self.0.write_to(sink).map(Ok) - } - - #[inline] - fn try_write_to_parts<S: PartsWrite + ?Sized>( - &self, - sink: &mut S, - ) -> Result<Result<(), Infallible>, fmt::Error> { - self.0.write_to_parts(sink).map(Ok) - } - - #[inline] - fn writeable_length_hint(&self) -> LengthHint { - self.0.writeable_length_hint() - } - - #[inline] - fn try_write_to_string(&self) -> Result<Cow<str>, (Infallible, Cow<str>)> { - Ok(self.0.write_to_string()) - } -} - -/// Testing macros for types implementing [`TryWriteable`]. -/// -/// Arguments, in order: -/// -/// 1. The [`TryWriteable`] under test -/// 2. The expected string value -/// 3. The expected result value, or `Ok(())` if omitted -/// 3. [`*_parts_eq`] only: a list of parts (`[(start, end, Part)]`) -/// -/// Any remaining arguments get passed to `format!` -/// -/// The macros tests the following: -/// -/// - Equality of string content -/// - Equality of parts ([`*_parts_eq`] only) -/// - Validity of size hint -/// -/// For a usage example, see [`TryWriteable`]. -/// -/// [`*_parts_eq`]: assert_try_writeable_parts_eq -#[macro_export] -macro_rules! assert_try_writeable_eq { - ($actual_writeable:expr, $expected_str:expr $(,)?) => { - $crate::assert_try_writeable_eq!($actual_writeable, $expected_str, Ok(())) - }; - ($actual_writeable:expr, $expected_str:expr, $expected_result:expr $(,)?) => { - $crate::assert_try_writeable_eq!($actual_writeable, $expected_str, $expected_result, "") - }; - ($actual_writeable:expr, $expected_str:expr, $expected_result:expr, $($arg:tt)+) => {{ - $crate::assert_try_writeable_eq!(@internal, $actual_writeable, $expected_str, $expected_result, $($arg)*); - }}; - (@internal, $actual_writeable:expr, $expected_str:expr, $expected_result:expr, $($arg:tt)+) => {{ - use $crate::TryWriteable; - let actual_writeable = &$actual_writeable; - let (actual_str, actual_parts, actual_error) = $crate::_internal::try_writeable_to_parts_for_test(actual_writeable); - assert_eq!(actual_str, $expected_str, $($arg)*); - assert_eq!(actual_error, Result::<(), _>::from($expected_result).err(), $($arg)*); - let actual_result = match actual_writeable.try_write_to_string() { - Ok(actual_cow_str) => { - assert_eq!(actual_cow_str, $expected_str, $($arg)+); - Ok(()) - } - Err((e, actual_cow_str)) => { - assert_eq!(actual_cow_str, $expected_str, $($arg)+); - Err(e) - } - }; - assert_eq!(actual_result, Result::<(), _>::from($expected_result), $($arg)*); - let length_hint = actual_writeable.writeable_length_hint(); - assert!( - length_hint.0 <= actual_str.len(), - "hint lower bound {} larger than actual length {}: {}", - length_hint.0, actual_str.len(), format!($($arg)*), - ); - if let Some(upper) = length_hint.1 { - assert!( - actual_str.len() <= upper, - "hint upper bound {} smaller than actual length {}: {}", - length_hint.0, actual_str.len(), format!($($arg)*), - ); - } - actual_parts // return for assert_try_writeable_parts_eq - }}; -} - -/// See [`assert_try_writeable_eq`]. -#[macro_export] -macro_rules! assert_try_writeable_parts_eq { - ($actual_writeable:expr, $expected_str:expr, $expected_parts:expr $(,)?) => { - $crate::assert_try_writeable_parts_eq!($actual_writeable, $expected_str, Ok(()), $expected_parts) - }; - ($actual_writeable:expr, $expected_str:expr, $expected_result:expr, $expected_parts:expr $(,)?) => { - $crate::assert_try_writeable_parts_eq!($actual_writeable, $expected_str, $expected_result, $expected_parts, "") - }; - ($actual_writeable:expr, $expected_str:expr, $expected_result:expr, $expected_parts:expr, $($arg:tt)+) => {{ - let actual_parts = $crate::assert_try_writeable_eq!(@internal, $actual_writeable, $expected_str, $expected_result, $($arg)*); - assert_eq!(actual_parts, $expected_parts, $($arg)+); - }}; -} - -#[test] -fn test_result_try_writeable() { - let mut result: Result<&str, usize> = Ok("success"); - assert_try_writeable_eq!(result, "success"); - result = Err(44); - assert_try_writeable_eq!(result, "44", Err(44)); - assert_try_writeable_parts_eq!(result, "44", Err(44), [(0, 2, Part::ERROR)]) -} |