Add OpenHashMap to stdlib

tests/pos-special/stdlib/collection/mutable/OpenHashMap.scala

@@ -0,0 +1,307 @@
+/*
+ * 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
+import language.experimental.captureChecking
+
+/**
+ * @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[sealed K, sealed V] = new OpenHashMap[K, V]
+ def from[sealed K, sealed V](it: IterableOnce[(K, V)]^): OpenHashMap[K,V] = empty ++= it
+
+ def newBuilder[sealed K, sealed 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[sealed Key, sealed 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[sealed Key, sealed 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"
+}