// 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));
}
}
