use crate::*;
use alloc::borrow::Cow;
use core::fmt;
macro_rules! impl_write_num {
($u:ty, $i:ty, $test:ident, $max_ilog_10:expr) => {
impl $crate::Writeable for $u {
fn write_to<W: core::fmt::Write + ?Sized>(&self, sink: &mut W) -> core::fmt::Result {
let mut buf = [b'0'; $max_ilog_10 + 1];
let mut n = *self;
let mut i = $max_ilog_10 + 1;
#[allow(clippy::indexing_slicing)] while n != 0 {
i -= 1;
buf[i] = b'0' + (n % 10) as u8;
n /= 10;
}
if i == buf.len() {
debug_assert_eq!(*self, 0);
i -= 1;
}
#[allow(clippy::indexing_slicing)] let s = unsafe { core::str::from_utf8_unchecked(&buf[i..]) };
sink.write_str(s)
}
fn writeable_length_hint(&self) -> $crate::LengthHint {
#[allow(unstable_name_collisions)] LengthHint::exact(self.checked_ilog10().unwrap_or(0) as usize + 1)
}
}
impl ILog10Ext for $u {
fn checked_ilog10(self) -> Option<u32> {
if self == 0 {
return None;
}
let b = (<$u>::BITS - 1) - self.leading_zeros();
const M: u32 = (core::f64::consts::LOG10_2 * (1 << 26) as f64) as u32;
let low = (b * M) >> 26;
let high = ((b + 1) * M) >> 26;
Some(if high == low {
low
} else if self < (10 as $u).pow(high) {
low
} else {
high
})
}
}
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); for _ in 0..1000 {
let rand = rng.gen::<$u>();
assert_writeable_eq!(rand, rand.to_string());
}
}
};
}
trait ILog10Ext: Sized {
fn checked_ilog10(self) -> Option<u32>;
}
impl_write_num!(u8, i8, test_u8, 2);
impl_write_num!(u16, i16, test_u16, 4);
impl_write_num!(u32, i32, test_u32, 9);
impl_write_num!(u64, i64, test_u64, 19);
impl_write_num!(u128, i128, test_u128, 38);
impl_write_num!(
usize,
isize,
test_usize,
if usize::MAX as u64 == u64::MAX { 19 } else { 9 }
);
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())
}
#[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<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()
}
}
#[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");
}
let arr: &[&str] = &["", "abc"];
check_writeable_slice(arr);
let arr: &[String] = &[String::new(), "abc".to_owned()];
check_writeable_slice(arr);
let arr: &[&String] = &[&String::new(), &"abc".to_owned()];
check_writeable_slice(arr);
}