1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
#![allow(non_snake_case)]
use std::collections::{HashMap, HashSet};
use std::hash::{Hasher, Hash, Writer};
use syntax::ast;
pub type FnvHashMap<K, V> = HashMap<K, V, FnvHasher>;
pub type FnvHashSet<V> = HashSet<V, FnvHasher>;
pub type NodeMap<T> = FnvHashMap<ast::NodeId, T>;
pub type DefIdMap<T> = FnvHashMap<ast::DefId, T>;
pub type NodeSet = FnvHashSet<ast::NodeId>;
pub type DefIdSet = FnvHashSet<ast::DefId>;
pub mod FnvHashMap {
use std::hash::Hash;
use std::collections::HashMap;
pub fn new<K: Hash<super::FnvState> + Eq, V>() -> super::FnvHashMap<K, V> {
HashMap::with_hasher(super::FnvHasher)
}
}
pub mod FnvHashSet {
use std::hash::Hash;
use std::collections::HashSet;
pub fn new<V: Hash<super::FnvState> + Eq>() -> super::FnvHashSet<V> {
HashSet::with_hasher(super::FnvHasher)
}
}
pub mod NodeMap {
pub fn new<T>() -> super::NodeMap<T> {
super::FnvHashMap::new()
}
}
pub mod DefIdMap {
pub fn new<T>() -> super::DefIdMap<T> {
super::FnvHashMap::new()
}
}
pub mod NodeSet {
pub fn new() -> super::NodeSet {
super::FnvHashSet::new()
}
}
pub mod DefIdSet {
pub fn new() -> super::DefIdSet {
super::FnvHashSet::new()
}
}
#[deriving(Clone, Copy, Default)]
pub struct FnvHasher;
#[allow(missing_copy_implementations)]
pub struct FnvState(u64);
impl Hasher<FnvState> for FnvHasher {
fn hash<Sized? T: Hash<FnvState>>(&self, t: &T) -> u64 {
let mut state = FnvState(0xcbf29ce484222325);
t.hash(&mut state);
let FnvState(ret) = state;
return ret;
}
}
impl Writer for FnvState {
fn write(&mut self, bytes: &[u8]) {
let FnvState(mut hash) = *self;
for byte in bytes.iter() {
hash = hash ^ (*byte as u64);
hash = hash * 0x100000001b3;
}
*self = FnvState(hash);
}
}