use alloc::{collections::BTreeMap, vec::Vec};
use core::ops::{Range, RangeInclusive};
use super::{RangeInclusiveMap, RangeMap};
#[derive(Eq, PartialEq, Debug)]
pub struct DenseU32RangeMap<V> {
btm: BTreeMap<u32, V>,
}
impl<V> DenseU32RangeMap<V>
where
V: Eq + Clone,
{
pub fn new() -> DenseU32RangeMap<V> {
DenseU32RangeMap {
btm: BTreeMap::new(),
}
}
pub fn insert(&mut self, range: RangeInclusive<u32>, value: V) {
for k in range {
self.btm.insert(k, value.clone());
}
}
pub fn iter(&self) -> Iter<'_, V> {
Iter {
inner: self.btm.iter(),
current: None,
}
}
pub fn end_exclusive_iter(&self) -> EndExclusiveIter<'_, V> {
EndExclusiveIter { inner: self.iter() }
}
pub fn to_vec(&self) -> Vec<(RangeInclusive<u32>, V)> {
self.iter()
.map(|(range, value)| (range, value.clone()))
.collect()
}
pub fn to_end_exclusive_vec(&self) -> Vec<(Range<u32>, V)> {
self.end_exclusive_iter()
.map(|(range, value)| (range, value.clone()))
.collect()
}
}
impl<V> From<RangeMap<u32, V>> for DenseU32RangeMap<V>
where
V: Eq + Clone,
{
fn from(range_map: RangeMap<u32, V>) -> Self {
let mut dense = Self::new();
for (range, value) in range_map.iter() {
#[allow(clippy::range_minus_one)]
dense.insert(range.start..=(range.end - 1), value.clone());
}
dense
}
}
impl<V> From<RangeInclusiveMap<u32, V>> for DenseU32RangeMap<V>
where
V: Eq + Clone,
{
fn from(range_inclusive_map: RangeInclusiveMap<u32, V, u32>) -> Self {
let mut dense = Self::new();
for (range, value) in range_inclusive_map.iter() {
dense.insert(range.clone(), value.clone());
}
dense
}
}
pub struct Iter<'a, V> {
inner: alloc::collections::btree_map::Iter<'a, u32, V>,
current: Option<(RangeInclusive<u32>, &'a V)>,
}
impl<'a, V> Iterator for Iter<'a, V>
where
V: 'a + Eq,
{
type Item = (RangeInclusive<u32>, &'a V);
fn next(&mut self) -> Option<(RangeInclusive<u32>, &'a V)> {
if let Some(next_dense) = self.inner.next() {
if let Some(current) = &mut self.current {
if current.0.end() + 1 == *next_dense.0 && *current.1 == *next_dense.1 {
*current = (*current.0.start()..=*next_dense.0, current.1);
self.next()
} else {
let item_to_yield = current.clone();
*current = (*next_dense.0..=*next_dense.0, next_dense.1);
Some(item_to_yield)
}
} else {
self.current = Some((*next_dense.0..=*next_dense.0, next_dense.1));
self.next()
}
} else {
self.current.take()
}
}
}
pub struct EndExclusiveIter<'a, V> {
inner: Iter<'a, V>,
}
impl<'a, V> Iterator for EndExclusiveIter<'a, V>
where
V: 'a + Eq,
{
type Item = (Range<u32>, &'a V);
fn next(&mut self) -> Option<(Range<u32>, &'a V)> {
self.inner
.next()
.map(|(range, value)| ((*range.start())..(*range.end() + 1), value))
}
}