use core::{
borrow::Borrow,
ops::{Bound, Index, RangeBounds}
};
use crate::internal::ordered_map::{self as internal, order};
pub type Iter<'a, K, V> = internal::Iter<'a, K, V>;
pub type Keys<'a, K, V> = internal::Keys<'a, K, V>;
pub type Range<'a, K, V> = internal::Iter<'a, K, V>;
pub type Values<'a, K, V> = internal::Values<'a, K, V>;
pub type Cursor<'a, K, V> = internal::Cursor<'a, K, V>;
pub type IterMut<'a, K, V> = internal::IterMut<'a, K, V>;
pub type RangeMut<'a, K, V> = internal::IterMut<'a, K, V>;
pub type ValuesMut<'a, K, V> = internal::ValuesMut<'a, K, V>;
pub type CursorMut<'a, K, V> = internal::CursorMut<'a, K, V>;
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct OrderedSliceMapMut<'a, K, V> {
inner: &'a mut [(K, V)],
len: usize
}
impl<'a, K, V> OrderedSliceMapMut<'a, K, V> {
pub fn new(items: &'a mut [(K, V)]) -> Self
where
K: Ord
{
let len = order(items);
OrderedSliceMapMut { inner: items, len }
}
pub const fn new_unchecked(ordered_items: &'a mut [(K, V)]) -> Self {
let len = ordered_items.len();
OrderedSliceMapMut {
inner: ordered_items,
len
}
}
pub fn is_valid(&self) -> bool
where
K: PartialOrd
{
internal::is_valid(&self.inner[..self.len])
}
pub fn contains_key<Q>(&self, key: &Q) -> bool
where
K: Borrow<Q>,
Q: PartialOrd + ?Sized
{
internal::contains_key(&self.inner[..self.len], key)
}
pub fn first_key_value(&self) -> Option<(&K, &V)> {
internal::first_key_value(&self.inner[..self.len])
}
pub fn get<Q>(&self, key: &Q) -> Option<&V>
where
K: Borrow<Q>,
Q: PartialOrd + ?Sized
{
internal::get(&self.inner[..self.len], key)
}
pub fn get_key_value<Q>(&self, key: &Q) -> Option<(&K, &V)>
where
K: Borrow<Q>,
Q: PartialOrd + ?Sized
{
internal::get_key_value(&self.inner[..self.len], key)
}
pub const fn is_empty(&self) -> bool {
self.len == 0
}
pub fn iter(&self) -> Iter<'_, K, V> {
internal::iter(&self.inner[..self.len])
}
pub fn keys(&self) -> Keys<'_, K, V> {
internal::keys(&self.inner[..self.len])
}
pub fn last_key_value(&self) -> Option<(&K, &V)> {
internal::last_key_value(&self.inner[..self.len])
}
pub const fn len(&self) -> usize {
self.len
}
pub fn lower_bound<Q>(&self, bound: Bound<&Q>) -> Cursor<'_, K, V>
where
K: Borrow<Q>,
Q: PartialOrd + ?Sized
{
internal::lower_bound(&self.inner[..self.len], bound)
}
pub fn range<Q, R>(&self, range: R) -> Range<'_, K, V>
where
K: Borrow<Q>,
Q: PartialOrd + ?Sized,
R: RangeBounds<Q>
{
internal::range(&self.inner[..self.len], range)
}
pub fn upper_bound<Q>(&self, bound: Bound<&Q>) -> Cursor<'_, K, V>
where
K: Borrow<Q>,
Q: PartialOrd + ?Sized
{
internal::upper_bound(&self.inner[..self.len], bound)
}
pub fn values(&self) -> Values<'_, K, V> {
internal::values(&self.inner[..self.len])
}
pub fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut V>
where
K: Borrow<Q>,
Q: PartialOrd + ?Sized
{
internal::get_mut(&mut self.inner[..self.len], key)
}
pub fn iter_mut(&mut self) -> IterMut<'_, K, V> {
internal::iter_mut(&mut self.inner[..self.len])
}
pub fn lower_bound_mut<Q>(&mut self, bound: Bound<&Q>) -> CursorMut<'_, K, V>
where
K: Borrow<Q>,
Q: PartialOrd + ?Sized
{
internal::lower_bound_mut(&mut self.inner[..self.len], bound)
}
pub fn range_mut<Q, R>(&mut self, range: R) -> RangeMut<'_, K, V>
where
K: Borrow<Q>,
Q: PartialOrd + ?Sized,
R: RangeBounds<Q>
{
internal::range_mut(&mut self.inner[..self.len], range)
}
pub fn upper_bound_mut<Q>(&mut self, bound: Bound<&Q>) -> CursorMut<'_, K, V>
where
K: Borrow<Q>,
Q: PartialOrd + ?Sized
{
internal::upper_bound_mut(&mut self.inner[..self.len], bound)
}
pub fn values_mut(&mut self) -> ValuesMut<'_, K, V> {
internal::values_mut(&mut self.inner[..self.len])
}
}
impl<'a, K, V> IntoIterator for &'a OrderedSliceMapMut<'a, K, V> {
type Item = (&'a K, &'a V);
type IntoIter = Iter<'a, K, V>;
fn into_iter(self) -> Self::IntoIter {
self.iter()
}
}
impl<'a, K, V> IntoIterator for &'a mut OrderedSliceMapMut<'a, K, V> {
type Item = (&'a K, &'a mut V);
type IntoIter = IterMut<'a, K, V>;
fn into_iter(self) -> Self::IntoIter {
self.iter_mut()
}
}
impl<'a, K, V, Q> Index<&Q> for OrderedSliceMapMut<'a, K, V>
where
K: Borrow<Q>,
Q: Ord
{
type Output = V;
fn index(&self, key: &Q) -> &Self::Output {
self.get(key).expect("no entry found for key")
}
}
#[cfg(test)]
mod tests {
use core::ops::Bound;
use super::*;
#[test]
fn test_get() {
let mut data = [(1, 'a'), (3, 'c'), (5, 'e')];
let map = OrderedSliceMapMut::new_unchecked(&mut data);
assert_eq!(map.get(&0), None);
assert_eq!(map.get(&1), Some(&'a'));
assert_eq!(map.get(&3), Some(&'c'));
assert_eq!(map.get(&5), Some(&'e'));
assert_eq!(map.get(&6), None);
}
#[test]
fn test_get_mut() {
let mut data = [(1, 10), (2, 20), (3, 30)];
let mut map = OrderedSliceMapMut::new_unchecked(&mut data);
if let Some(v) = map.get_mut(&2) {
*v = 200;
}
assert_eq!(map.get(&2), Some(&200));
assert_eq!(map.get(&1), Some(&10));
}
#[test]
fn test_iter_mut() {
let mut data = [(1, 1), (2, 4), (3, 9)];
let mut map = OrderedSliceMapMut::new_unchecked(&mut data);
for (_, v) in map.iter_mut() {
*v *= 2;
}
assert_eq!(map.get(&1), Some(&2));
assert_eq!(map.get(&2), Some(&8));
assert_eq!(map.get(&3), Some(&18));
}
#[test]
fn test_lower_bound() {
let mut data = [(1, 1), (3, 9), (5, 25)];
let map = OrderedSliceMapMut::new_unchecked(&mut data);
assert_eq!(map.lower_bound(Bound::Included(&2)).next(), Some((&3, &9)));
assert_eq!(map.lower_bound(Bound::Excluded(&3)).next(), Some((&5, &25)));
assert_eq!(map.lower_bound(Bound::Unbounded).next(), Some((&1, &1)));
assert_eq!(map.lower_bound(Bound::Included(&6)).next(), None);
}
#[test]
fn test_values_mut() {
let mut data = [(1, 1), (2, 2), (3, 3)];
let mut map = OrderedSliceMapMut::new_unchecked(&mut data);
for v in map.values_mut() {
*v += 10;
}
assert_eq!(map.get(&1), Some(&11));
assert_eq!(map.get(&2), Some(&12));
assert_eq!(map.get(&3), Some(&13));
}
#[test]
fn test_index_operator() {
let mut data = [(5, 50), (10, 100)];
let map = OrderedSliceMapMut::new_unchecked(&mut data);
assert_eq!(map[&5], 50);
assert_eq!(map[&10], 100);
}
}