-
Notifications
You must be signed in to change notification settings - Fork 3.1k
/
OpenHashMap.scala
306 lines (260 loc) · 10.1 KB
/
OpenHashMap.scala
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
/*
* Scala (https://www.scala-lang.org)
*
* Copyright EPFL and Lightbend, Inc.
*
* Licensed under Apache License 2.0
* (http://www.apache.org/licenses/LICENSE-2.0).
*
* See the NOTICE file distributed with this work for
* additional information regarding copyright ownership.
*/
package scala.collection
package mutable
import java.lang.Integer.numberOfLeadingZeros
import java.util.ConcurrentModificationException
import scala.collection.generic.DefaultSerializable
/**
* @define Coll `OpenHashMap`
* @define coll open hash map
*/
@deprecated("Use HashMap or one of the specialized versions (LongMap, AnyRefMap) instead of OpenHashMap", "2.13.0")
@SerialVersionUID(3L)
object OpenHashMap extends MapFactory[OpenHashMap] {
def empty[K, V] = new OpenHashMap[K, V]
def from[K, V](it: IterableOnce[(K, V)]): OpenHashMap[K,V] = empty ++= it
def newBuilder[K, V]: Builder[(K, V), OpenHashMap[K,V]] =
new GrowableBuilder[(K, V), OpenHashMap[K, V]](empty)
/** A hash table entry.
*
* The entry is occupied if and only if its `value` is a `Some`;
* deleted if and only if its `value` is `None`.
* If its `key` is not the default value of type `Key`, the entry is occupied.
* If the entry is occupied, `hash` contains the hash value of `key`.
*/
final private class OpenEntry[Key, Value](var key: Key,
var hash: Int,
var value: Option[Value])
private[mutable] def nextPositivePowerOfTwo(target: Int): Int = 1 << -numberOfLeadingZeros(target - 1)
}
/** A mutable hash map based on an open addressing method. The precise scheme is
* undefined, but it should make a reasonable effort to ensure that an insert
* with consecutive hash codes is not unnecessarily penalised. In particular,
* mappings of consecutive integer keys should work without significant
* performance loss.
*
* @tparam Key type of the keys in this map.
* @tparam Value type of the values in this map.
* @param initialSize the initial size of the internal hash table.
*
* @define Coll `OpenHashMap`
* @define coll open hash map
* @define mayNotTerminateInf
* @define willNotTerminateInf
*/
@deprecated("Use HashMap or one of the specialized versions (LongMap, AnyRefMap) instead of OpenHashMap", "2.13.0")
class OpenHashMap[Key, Value](initialSize : Int)
extends AbstractMap[Key, Value]
with MapOps[Key, Value, OpenHashMap, OpenHashMap[Key, Value]]
with StrictOptimizedIterableOps[(Key, Value), Iterable, OpenHashMap[Key, Value]]
with MapFactoryDefaults[Key, Value, OpenHashMap, Iterable]
with DefaultSerializable {
import OpenHashMap.OpenEntry
private type Entry = OpenEntry[Key, Value]
/** A default constructor creates a hashmap with initial size `8`.
*/
def this() = this(8)
override def mapFactory: MapFactory[OpenHashMap] = OpenHashMap
private[this] val actualInitialSize = OpenHashMap.nextPositivePowerOfTwo(initialSize)
private[this] var mask = actualInitialSize - 1
/** The hash table.
*
* The table's entries are initialized to `null`, indication of an empty slot.
* A slot is either deleted or occupied if and only if the entry is non-`null`.
*/
private[this] var table = new Array[Entry](actualInitialSize)
private[this] var _size = 0
private[this] var deleted = 0
// Used for tracking inserts so that iterators can determine if concurrent modification has occurred.
private[this] var modCount = 0
override def size = _size
override def knownSize: Int = size
private[this] def size_=(s : Int): Unit = _size = s
override def isEmpty: Boolean = _size == 0
/** Returns a mangled hash code of the provided key. */
protected def hashOf(key: Key) = {
var h = key.##
h ^= ((h >>> 20) ^ (h >>> 12))
h ^ (h >>> 7) ^ (h >>> 4)
}
/** Increase the size of the table.
* Copy only the occupied slots, effectively eliminating the deleted slots.
*/
private[this] def growTable() = {
val oldSize = mask + 1
val newSize = 4 * oldSize
val oldTable = table
table = new Array[Entry](newSize)
mask = newSize - 1
oldTable.foreach( entry =>
if (entry != null && entry.value != None)
table(findIndex(entry.key, entry.hash)) = entry )
deleted = 0
}
/** Return the index of the first slot in the hash table (in probe order)
* that is, in order of preference, either occupied by the given key, deleted, or empty.
*
* @param hash hash value for `key`
*/
private[this] def findIndex(key: Key, hash: Int): Int = {
var index = hash & mask
var j = 0
// Index of the first slot containing a deleted entry, or -1 if none found yet
var firstDeletedIndex = -1
var entry = table(index)
while (entry != null) {
if (entry.hash == hash && entry.key == key && entry.value != None)
return index
if (firstDeletedIndex == -1 && entry.value == None)
firstDeletedIndex = index
j += 1
index = (index + j) & mask
entry = table(index)
}
if (firstDeletedIndex == -1) index else firstDeletedIndex
}
// TODO refactor `put` to extract `findOrAddEntry` and implement this in terms of that to avoid Some boxing.
override def update(key: Key, value: Value): Unit = put(key, value)
@deprecatedOverriding("addOne should not be overridden in order to maintain consistency with put.", "2.11.0")
def addOne (kv: (Key, Value)): this.type = { put(kv._1, kv._2); this }
@deprecatedOverriding("subtractOne should not be overridden in order to maintain consistency with remove.", "2.11.0")
def subtractOne (key: Key): this.type = { remove(key); this }
override def put(key: Key, value: Value): Option[Value] =
put(key, hashOf(key), value)
private def put(key: Key, hash: Int, value: Value): Option[Value] = {
if (2 * (size + deleted) > mask) growTable()
val index = findIndex(key, hash)
val entry = table(index)
if (entry == null) {
table(index) = new OpenEntry(key, hash, Some(value))
modCount += 1
size += 1
None
} else {
val res = entry.value
if (entry.value == None) {
entry.key = key
entry.hash = hash
size += 1
deleted -= 1
modCount += 1
}
entry.value = Some(value)
res
}
}
/** Delete the hash table slot contained in the given entry. */
@`inline`
private[this] def deleteSlot(entry: Entry) = {
entry.key = null.asInstanceOf[Key]
entry.hash = 0
entry.value = None
size -= 1
deleted += 1
}
override def remove(key : Key): Option[Value] = {
val entry = table(findIndex(key, hashOf(key)))
if (entry != null && entry.value != None) {
val res = entry.value
deleteSlot(entry)
res
} else None
}
def get(key : Key) : Option[Value] = {
val hash = hashOf(key)
var index = hash & mask
var entry = table(index)
var j = 0
while(entry != null){
if (entry.hash == hash &&
entry.key == key){
return entry.value
}
j += 1
index = (index + j) & mask
entry = table(index)
}
None
}
/** An iterator over the elements of this map. Use of this iterator follows
* the same contract for concurrent modification as the foreach method.
*
* @return the iterator
*/
def iterator: Iterator[(Key, Value)] = new OpenHashMapIterator[(Key, Value)] {
override protected def nextResult(node: Entry): (Key, Value) = (node.key, node.value.get)
}
override def keysIterator: Iterator[Key] = new OpenHashMapIterator[Key] {
override protected def nextResult(node: Entry): Key = node.key
}
override def valuesIterator: Iterator[Value] = new OpenHashMapIterator[Value] {
override protected def nextResult(node: Entry): Value = node.value.get
}
private abstract class OpenHashMapIterator[A] extends AbstractIterator[A] {
private[this] var index = 0
private[this] val initialModCount = modCount
private[this] def advance(): Unit = {
if (initialModCount != modCount) throw new ConcurrentModificationException
while((index <= mask) && (table(index) == null || table(index).value == None)) index+=1
}
def hasNext = {advance(); index <= mask }
def next() = {
advance()
val result = table(index)
index += 1
nextResult(result)
}
protected def nextResult(node: Entry): A
}
override def clone() = {
val it = new OpenHashMap[Key, Value]
foreachUndeletedEntry(entry => it.put(entry.key, entry.hash, entry.value.get))
it
}
/** Loop over the key, value mappings of this map.
*
* The behaviour of modifying the map during an iteration is as follows:
* - Deleting a mapping is always permitted.
* - Changing the value of mapping which is already present is permitted.
* - Anything else is not permitted. It will usually, but not always, throw an exception.
*
* @tparam U The return type of the specified function `f`, return result of which is ignored.
* @param f The function to apply to each key, value mapping.
*/
override def foreach[U](f : ((Key, Value)) => U): Unit = {
val startModCount = modCount
foreachUndeletedEntry(entry => {
if (modCount != startModCount) throw new ConcurrentModificationException
f((entry.key, entry.value.get))}
)
}
override def foreachEntry[U](f : (Key, Value) => U): Unit = {
val startModCount = modCount
foreachUndeletedEntry(entry => {
if (modCount != startModCount) throw new ConcurrentModificationException
f(entry.key, entry.value.get)}
)
}
private[this] def foreachUndeletedEntry(f : Entry => Unit): Unit = {
table.foreach(entry => if (entry != null && entry.value != None) f(entry))
}
override def mapValuesInPlace(f : (Key, Value) => Value): this.type = {
foreachUndeletedEntry(entry => entry.value = Some(f(entry.key, entry.value.get)))
this
}
override def filterInPlace(f : (Key, Value) => Boolean): this.type = {
foreachUndeletedEntry(entry => if (!f(entry.key, entry.value.get)) deleteSlot(entry))
this
}
override protected[this] def stringPrefix = "OpenHashMap"
}