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