use crate::{Error, Result};
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ComputedDimensions {
first: (usize, usize),
rest: Vec<(usize, usize)>,
}
impl ComputedDimensions {
pub fn through(maximum: usize) -> Self {
Self {
first: (0, maximum),
rest: Vec::new(),
}
}
pub fn new(mut dimensions: Vec<usize>) -> Result<Self> {
dimensions.sort_unstable();
let Some(&start) = dimensions.first() else {
return Err(Error::InvalidParameter {
parameter: "computed dimensions",
reason: "at least one computed dimension is required",
});
};
let mut result = Self {
first: (start, start),
rest: Vec::new(),
};
for dimension in dimensions.into_iter().skip(1) {
let last = result.rest.last_mut().unwrap_or(&mut result.first);
if dimension <= last.1 || last.1.checked_add(1) == Some(dimension) {
last.1 = dimension;
} else {
result
.rest
.try_reserve(1)
.map_err(|_| Error::AllocationFailed {
context: "computed dimension ranges",
})?;
result.rest.push((dimension, dimension));
}
}
Ok(result)
}
pub fn contains(&self, dimension: usize) -> bool {
if dimension <= self.first.1 {
return dimension >= self.first.0;
}
let position = self.rest.partition_point(|&(_, end)| end < dimension);
self.rest
.get(position)
.is_some_and(|&(start, _)| start <= dimension)
}
pub fn iter(&self) -> impl DoubleEndedIterator<Item = usize> + '_ {
std::iter::once(self.first)
.chain(self.rest.iter().copied())
.flat_map(|(start, end)| start..=end)
}
pub fn max(&self) -> usize {
self.rest.last().unwrap_or(&self.first).1
}
}