Forward additional methods

JelteF · Aug 23, 2023 · f635768 · f635768
1 parent af90158
commit f635768
Show file tree

Hide file tree

Showing 2 changed files with 143 additions and 41 deletions.
diff --git a/src/btreemap.rs b/src/btreemap.rs
@@ -1,6 +1,7 @@
 use derive_more::Debug;
 use std::borrow::Borrow;
 use std::collections::btree_map::*;
+use std::ops::RangeBounds;
 use std::collections::BTreeMap;
 use std::iter::{FromIterator, IntoIterator};
 use std::ops::{Index, IndexMut};
@@ -183,44 +184,50 @@ impl<K: Eq + Ord, V> IndexMut<K> for DefaultBTreeMap<K, V> {
 /// the usage of these methods.
 impl<K: Eq + Ord, V> DefaultBTreeMap<K, V> {
  #[inline]
- pub fn keys(&self) -> Keys<K, V> {
- self.map.keys()
- }
- #[inline]
- pub fn values(&self) -> Values<K, V> {
- self.map.values()
- }
- #[inline]
- pub fn values_mut(&mut self) -> ValuesMut<K, V> {
- self.map.values_mut()
- }
- #[inline]
- pub fn iter(&self) -> Iter<K, V> {
- self.map.iter()
+ pub fn clear(&mut self) {
+ self.map.clear()
  }
  #[inline]
- pub fn iter_mut(&mut self) -> IterMut<K, V> {
- self.map.iter_mut()
+ pub fn first_key_value(&self) -> Option<(&K, &V)>
+ where
+ K: Ord,
+ {
+ self.map.first_key_value()
  }
  #[inline]
- pub fn entry(&mut self, key: K) -> Entry<K, V> {
- self.map.entry(key)
+ pub fn first_entry(&mut self) -> Option<OccupiedEntry<'_, K, V>>
+ where
+ K: Ord,
+ {
+ self.map.first_entry()
  }
  #[inline]
- pub fn len(&self) -> usize {
- self.map.len()
+ pub fn pop_first(&mut self) -> Option<(K, V)>
+ where
+ K: Ord,
+ {
+ self.map.pop_first()
  }
  #[inline]
- pub fn is_empty(&self) -> bool {
- self.map.is_empty()
+ pub fn last_key_value(&self) -> Option<(&K, &V)>
+ where
+ K: Ord,
+ {
+ self.map.last_key_value()
  }
  #[inline]
- pub fn clear(&mut self) {
- self.map.clear()
+ pub fn last_entry(&mut self) -> Option<OccupiedEntry<'_, K, V>>
+ where
+ K: Ord,
+ {
+ self.map.last_entry()
  }
  #[inline]
- pub fn insert(&mut self, k: K, v: V) -> Option<V> {
- self.map.insert(k, v)
+ pub fn pop_last(&mut self) -> Option<(K, V)>
+ where
+ K: Ord,
+ {
+ self.map.pop_last()
  }
  #[inline]
  pub fn contains_key<Q>(&self, k: &Q) -> bool
@@ -231,6 +238,10 @@ impl<K: Eq + Ord, V> DefaultBTreeMap<K, V> {
  self.map.contains_key(k)
  }
  #[inline]
+ pub fn insert(&mut self, k: K, v: V) -> Option<V> {
+ self.map.insert(k, v)
+ }
+ #[inline]
  pub fn remove<Q>(&mut self, k: &Q) -> Option<V>
  where
  K: Borrow<Q>,
@@ -245,6 +256,70 @@ impl<K: Eq + Ord, V> DefaultBTreeMap<K, V> {
  {
  self.map.retain(f)
  }
+ #[inline]
+ pub fn append(&mut self, other: &mut Self)
+ {
+ self.map.append(&mut other.map)
+ }
+ #[inline]
+ pub fn range<T: ?Sized, R>(&self, range: R) -> Range<'_, K, V>
+ where
+ T: Ord,
+ K: Borrow<T> + Ord,
+ R: RangeBounds<T>,
+ {
+ self.map.range(range)
+ }
+ #[inline]
+ pub fn range_mut<T: ?Sized, R>(&mut self, range: R) -> RangeMut<'_, K, V>
+ where
+ T: Ord,
+ K: Borrow<T> + Ord,
+ R: RangeBounds<T>,
+ {
+ self.map.range_mut(range)
+ }
+ #[inline]
+ pub fn entry(&mut self, key: K) -> Entry<K, V> {
+ self.map.entry(key)
+ }
+ #[inline]
+ pub fn into_keys(self) -> IntoKeys<K, V> {
+ self.map.into_keys()
+ }
+ #[inline]
+ pub fn into_values(self) -> IntoValues<K, V> {
+ self.map.into_values()
+ }
+
+ #[inline]
+ pub fn iter(&self) -> Iter<K, V> {
+ self.map.iter()
+ }
+ #[inline]
+ pub fn iter_mut(&mut self) -> IterMut<K, V> {
+ self.map.iter_mut()
+ }
+ #[inline]
+ pub fn keys(&self) -> Keys<K, V> {
+ self.map.keys()
+ }
+ #[inline]
+ pub fn values(&self) -> Values<K, V> {
+ self.map.values()
+ }
+ #[inline]
+ pub fn values_mut(&mut self) -> ValuesMut<K, V> {
+ self.map.values_mut()
+ }
+ #[inline]
+ pub fn len(&self) -> usize {
+ self.map.len()
+ }
+ #[inline]
+ pub fn is_empty(&self) -> bool {
+ self.map.is_empty()
+ }
 }
 
 impl<K: Eq + Ord, V: Default> FromIterator<(K, V)> for DefaultBTreeMap<K, V> {

diff --git a/src/hashmap.rs b/src/hashmap.rs
@@ -1,6 +1,7 @@
 use derive_more::Debug;
 use std::borrow::Borrow;
 use std::collections::hash_map::*;
+use std::collections::TryReserveError;
 use std::collections::HashMap;
 use std::hash::Hash;
 use std::iter::{FromIterator, IntoIterator};
@@ -187,18 +188,14 @@ impl<K: Eq + Hash, V> DefaultHashMap<K, V> {
  self.map.capacity()
  }
  #[inline]
- pub fn reserve(&mut self, additional: usize) {
- self.map.reserve(additional)
- }
- #[inline]
- pub fn shrink_to_fit(&mut self) {
- self.map.shrink_to_fit()
- }
- #[inline]
  pub fn keys(&self) -> Keys<K, V> {
  self.map.keys()
  }
  #[inline]
+ pub fn into_keys(self) -> IntoKeys<K, V> {
+ self.map.into_keys()
+ }
+ #[inline]
  pub fn values(&self) -> Values<K, V> {
  self.map.values()
  }
@@ -207,6 +204,10 @@ impl<K: Eq + Hash, V> DefaultHashMap<K, V> {
  self.map.values_mut()
  }
  #[inline]
+ pub fn into_values(self) -> IntoValues<K, V> {
+ self.map.into_values()
+ }
+ #[inline]
  pub fn iter(&self) -> Iter<K, V> {
  self.map.iter()
  }
@@ -215,10 +216,6 @@ impl<K: Eq + Hash, V> DefaultHashMap<K, V> {
  self.map.iter_mut()
  }
  #[inline]
- pub fn entry(&mut self, key: K) -> Entry<K, V> {
- self.map.entry(key)
- }
- #[inline]
  pub fn len(&self) -> usize {
  self.map.len()
  }
@@ -231,9 +228,37 @@ impl<K: Eq + Hash, V> DefaultHashMap<K, V> {
  self.map.drain()
  }
  #[inline]
+ pub fn retain<RF>(&mut self, f: RF)
+ where
+ RF: FnMut(&K, &mut V) -> bool,
+ {
+ self.map.retain(f)
+ }
+ #[inline]
  pub fn clear(&mut self) {
  self.map.clear()
  }
+ #[inline]
+ pub fn reserve(&mut self, additional: usize) {
+ self.map.reserve(additional)
+ }
+ #[inline]
+ pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError> {
+ self.map.try_reserve(additional)
+ }
+ #[inline]
+ pub fn shrink_to_fit(&mut self) {
+ self.map.shrink_to_fit()
+ }
+ #[inline]
+ pub fn shrink_to(&mut self, min_capacity: usize) {
+ self.map.shrink_to(min_capacity);
+ }
+ #[inline]
+ pub fn entry(&mut self, key: K) -> Entry<K, V> {
+ self.map.entry(key)
+ }
+
  #[inline]
  pub fn insert(&mut self, k: K, v: V) -> Option<V> {
  self.map.insert(k, v)
@@ -255,12 +280,14 @@ impl<K: Eq + Hash, V> DefaultHashMap<K, V> {
  self.map.remove(k)
  }
  #[inline]
- pub fn retain<RF>(&mut self, f: RF)
+ pub fn remove_entry<Q: ?Sized>(&mut self, k: &Q) -> Option<(K, V)>
  where
- RF: FnMut(&K, &mut V) -> bool,
+ K: Borrow<Q>,
+ Q: Hash + Eq,
  {
- self.map.retain(f)
+ self.map.remove_entry(k)
  }
+
 }
 
 impl<K: Eq + Hash, V: Default> FromIterator<(K, V)> for DefaultHashMap<K, V> {