我正在尝试创建一个DefaultHashMap
结构,它基本上是HashMap
的包装器,不同之处在于当获取不在地图中的键时,默认值放在该键中并被退回。
我制作了get
和get_mut
方法,这很好用。现在我正在尝试实现Index
和IndexMut
作为这些方法的包装器。在这里,我遇到了两个问题。
第一个问题是由于get
在密钥不存在时必须改变结构的事实,它需要一个可变引用。但是,index
Index
方法的签名有&self
而不是&mut self
,因此我无法实现。
这会导致第二个问题,IndexMut
需要Index
实施。因此,即使IndexMut
没有实现任何问题,我也无法执行此操作,因为Index
无法实现。
第一个问题很烦人,但可以理解。对于第二个,我不明白为什么要求就在那里。我想有办法解决它。现在我正在做以下事情,但我希望有人有更好的解决方案:
impl<K: Eq + Hash, V: Clone> Index<K> for DefaultHashMap<K, V> {
type Output = V;
fn index(&self, _: K) -> &V {
panic!("DefautHashMap doesn't implement indexing without mutating")
}
}
impl<K: Eq + Hash, V: Clone> IndexMut<K> for DefaultHashMap<K, V> {
#[inline]
fn index_mut(&mut self, index: K) -> &mut V {
self.get_mut(index)
}
}
答案 0 :(得分:5)
首先,我怀疑你的要求“在获取不在地图中的密钥时,默认值放在那个密钥中”并不是完全必需的!
考虑不可变访问let foo = default_hash_map[bar] + 123;
。除非你打算在地图中使用具有内部可变性的值,否则default_hash_map[bar]
实际创建一个键或只返回对单个默认值的引用可能无关紧要。
现在,如果您确实需要在访问期间创建新条目,那么有一种方法可以执行此操作。借用检查器限制只允许您添加具有可变访问权限的新条目,这是为了阻止您创建悬挂指针,这些指针会在您按住引用的同时修改地图时发生。但是如果你使用的是一个带有稳定引用的结构,那么当你在结构中输入新条目时,stable表示引用不会失效,那么借用检查器试图阻止的问题就会消失。
在C ++中,我会考虑使用标准保证的deque,以便在向其添加新条目时使其引用无效。不幸的是,Rust deques是不同的(虽然您可能会找到具有类似于C ++双端队列的属性的 arena allocator crates),因此对于此示例我使用Box
。盒装值分别驻留在堆上,并且在将新条目添加到HashMap
时不会移动。
现在,您的正常访问模式可能是修改新条目,然后访问地图的现有条目。因此,在Index::index
中创建新条目是一个例外,不应该减慢地图的其余部分。因此,仅为Index::index
访问支付拳击价格可能是有意义的。要做到这一点,我们可能会使用第二个结构,它只保留盒装的Index::index
值。
知道可以插入HashMap<K, Box<V>>
而不会使现有的V
引用无效允许我们将其用作临时缓冲区,保留Index::index
- 创建的值,直到我们有机会将它们与主要HashMap
同步。
use std::borrow::Borrow;
use std::cell::UnsafeCell;
use std::collections::HashMap;
use std::hash::Hash;
use std::ops::Index;
use std::ops::IndexMut;
struct DefaultHashMap<K, V>(HashMap<K, V>, UnsafeCell<HashMap<K, Box<V>>>, V);
impl<K, V> DefaultHashMap<K, V>
where K: Eq + Hash
{
fn sync(&mut self) {
let buf_map = unsafe { &mut *self.1.get() };
for (k, v) in buf_map.drain() {
self.0.insert(k, *v);
}
}
}
impl<'a, K, V, Q: ?Sized> Index<&'a Q> for DefaultHashMap<K, V>
where K: Eq + Hash + Clone,
K: Borrow<Q>,
K: From<&'a Q>,
Q: Eq + Hash,
V: Clone
{
type Output = V;
fn index(&self, key: &'a Q) -> &V {
if let Some(v) = self.0.get(key) {
v
} else {
let buf_map: &mut HashMap<K, Box<V>> = unsafe { &mut *self.1.get() };
if !buf_map.contains_key(key) {
buf_map.insert(K::from(key), Box::new(self.2.clone()));
}
&*buf_map.get(key).unwrap()
}
}
}
impl<'a, K, V, Q: ?Sized> IndexMut<&'a Q> for DefaultHashMap<K, V>
where K: Eq + Hash + Clone,
K: Borrow<Q>,
K: From<&'a Q>,
Q: Eq + Hash,
V: Clone
{
fn index_mut(&mut self, key: &'a Q) -> &mut V {
self.sync();
if self.0.contains_key(key) {
self.0.get_mut(key).unwrap()
} else {
self.0.insert(K::from(key), self.2.clone());
self.0.get_mut(key).unwrap()
}
}
}
fn main() {
{
let mut dhm = DefaultHashMap::<String, String>(HashMap::new(),
UnsafeCell::new(HashMap::new()),
"bar".into());
for i in 0..10000 {
dhm[&format!("{}", i % 1000)[..]].push('x')
}
println!("{:?}", dhm.0);
}
{
let mut dhm = DefaultHashMap::<String, String>(HashMap::new(),
UnsafeCell::new(HashMap::new()),
"bar".into());
for i in 0..10000 {
let key = format!("{}", i % 1000);
assert!(dhm[&key].len() >= 3);
dhm[&key[..]].push('x');
}
println!("{:?}", dhm.0);
}
{
#[derive(Eq, PartialEq, Clone, Copy, Hash, Debug)]
struct K(u32);
impl<'a> From<&'a u32> for K {
fn from(v: &u32) -> K {
K(*v)
}
}
impl<'a> Borrow<u32> for K {
fn borrow(&self) -> &u32 {
&self.0
}
}
let mut dhm = DefaultHashMap::<K, K>(HashMap::new(),
UnsafeCell::new(HashMap::new()),
K::from(&123));
for i in 0..10000 {
let key = i % 1000;
assert!(dhm[&key].0 >= 123);
dhm[&key].0 += 1;
}
println!("{:?}", dhm.0);
}
}
请注意,装箱只会稳定新条目的插入。要删除已装箱的条目,您仍需要对&mut self
进行可变(DefaultHashMap
)访问。