add getOrElse,getOrElseUpdate and other operation

liang3zy22 · lrytz · commit 200f520c9855 · 2022-12-14T13:50:37.000+01:00
Add getOrElse, getOrElseUpdate, hashCode,sizeHint
operation in LinkedHashMap.
Add entry iterator in LinkedHashMap/LinkedHashSet.
Add optimization in immutable.{HashMap, HashSet} and
mutable.{HashMap, HashSet}.

Signed-off-by: Liang Yan &lt;ckgppl_yan@sina.cn&gt;
diff --git a/library/src/scala/collection/immutable/HashMap.scala b/library/src/scala/collection/immutable/HashMap.scala
@@ -190,6 +190,27 @@ final class HashMap[K, +V] private[immutable] (private[immutable] val rootNode:
         }
       }
       this
+    case lhm: mutable.LinkedHashMap[K @unchecked, V @unchecked] =>
+      val iter = lhm.entryIterator
+      var current = rootNode
+      while (iter.hasNext) {
+        val next = iter.next()
+        val originalHash = lhm.unimproveHash(next.hash)
+        val improved = improve(originalHash)
+        current = current.updated(next.key, next.value, originalHash, improved, 0, replaceValue = true)
+
+        if (current ne rootNode) {
+          var shallowlyMutableNodeMap = Node.bitposFrom(Node.maskFrom(improved, 0))
+
+          while (iter.hasNext) {
+            val next = iter.next()
+            val originalHash = lhm.unimproveHash(next.hash)
+            shallowlyMutableNodeMap = current.updateWithShallowMutations(next.key, next.value, originalHash, improve(originalHash), 0, shallowlyMutableNodeMap)
+          }
+          return new HashMap(current)
+        }
+      }
+      this
     case _ =>
       class accum extends AbstractFunction2[K, V1, Unit] with Function1[(K, V1), Unit] {
         var changed = false
@@ -397,6 +418,24 @@ final class HashMap[K, +V] private[immutable] (private[immutable] val rootNode:
             }
             newHashMapOrThis(curr)
           }
+        case lhashSet: collection.mutable.LinkedHashSet[K] =>
+          if (lhashSet.isEmpty) {
+            this
+          } else {
+            val iter = lhashSet.entryIterator
+            var curr = rootNode
+
+            while (iter.hasNext) {
+              val next = iter.next()
+              val originalHash = lhashSet.unimproveHash(next.hash)
+              val improved = improve(originalHash)
+              curr = curr.removed(next.key, originalHash, improved, 0)
+              if (curr.size == 0) {
+                return HashMap.empty
+              }
+            }
+            newHashMapOrThis(curr)
+          }
         case _ =>
           val iter = keys.iterator
           var curr = rootNode
@@ -2353,6 +2392,14 @@ private[immutable] final class HashMapBuilder[K, V] extends ReusableBuilder[(K,
           val hash = improve(originalHash)
           update(rootNode, next.key, next.value, originalHash, hash, 0)
         }
+      case lhm: collection.mutable.LinkedHashMap[K, V] =>
+        val iter = lhm.entryIterator
+        while (iter.hasNext) {
+          val next = iter.next()
+          val originalHash = lhm.unimproveHash(next.hash)
+          val hash = improve(originalHash)
+          update(rootNode, next.key, next.value, originalHash, hash, 0)
+        }
       case thatMap: Map[K, V] =>
         thatMap.foreachEntry((key, value) => addOne(key, value))
       case other =>
diff --git a/library/src/scala/collection/immutable/HashSet.scala b/library/src/scala/collection/immutable/HashSet.scala
@@ -121,6 +121,27 @@ final class HashSet[A] private[immutable](private[immutable] val rootNode: Bitma
           }
         }
         this
+      case lhs: collection.mutable.LinkedHashSet[A] =>
+        val iter = lhs.entryIterator
+        var current = rootNode
+        while (iter.hasNext) {
+          val next = iter.next()
+          val originalHash = lhs.unimproveHash(next.hash)
+          val improved = improve(originalHash)
+          current = current.updated(next.key, originalHash, improved, 0)
+
+          if (current ne rootNode) {
+            var shallowlyMutableNodeMap = Node.bitposFrom(Node.maskFrom(improved, 0))
+            while (iter.hasNext) {
+              val next = iter.next()
+              val originalHash = lhs.unimproveHash(next.hash)
+              val improved = improve(originalHash)
+              shallowlyMutableNodeMap = current.updateWithShallowMutations(next.key, originalHash, improved, 0, shallowlyMutableNodeMap)
+            }
+            return new HashSet(current)
+          }
+        }
+        this
       case _ =>
         val iter = that.iterator
         var current = rootNode
diff --git a/library/src/scala/collection/mutable/HashMap.scala b/library/src/scala/collection/mutable/HashMap.scala
@@ -108,6 +108,13 @@ class HashMap[K, V](initialCapacity: Int, loadFactor: Double)
           put0(next.key, next.value, next.hash, getOld = false)
         }
         this
+      case lhm: mutable.LinkedHashMap[K, V] =>
+      val iter = lhm.entryIterator
+      while (iter.hasNext) {
+        val entry = iter.next()
+        put0(entry.key, entry.value,entry.hash,getOld = false)
+      }
+      this
       case thatMap: Map[K, V] =>
         thatMap.foreachEntry { (key: K, value: V) =>
           put0(key, value, improveHash(key.##), getOld = false)
@@ -195,6 +202,14 @@ class HashMap[K, V](initialCapacity: Int, loadFactor: Double)
           if (size == 0) return this
         }
         this
+      case lhs: mutable.LinkedHashSet[K] =>
+        val iter = lhs.entryIterator
+        while (iter.hasNext) {
+          val next = iter.next()
+          remove0(next.key, next.hash)
+          if (size == 0) return this
+        }
+        this
       case _ => super.subtractAll(xs)
     }
   }
diff --git a/library/src/scala/collection/mutable/HashSet.scala b/library/src/scala/collection/mutable/HashSet.scala
@@ -93,11 +93,18 @@ final class HashSet[A](initialCapacity: Int, loadFactor: Double)
   override def addAll(xs: IterableOnce[A]): this.type = {
     sizeHint(xs.knownSize)
     xs match {
-      case hm: immutable.HashSet[A] =>
-        hm.foreachWithHash((k, h) => addElem(k, improveHash(h)))
+      case hs: immutable.HashSet[A] =>
+        hs.foreachWithHash((k, h) => addElem(k, improveHash(h)))
+        this
+      case hs: mutable.HashSet[A] =>
+        val iter = hs.nodeIterator
+        while (iter.hasNext) {
+          val next = iter.next()
+          addElem(next.key, next.hash)
+        }
         this
-      case hm: mutable.HashSet[A] =>
-        val iter = hm.nodeIterator
+      case lhs: mutable.LinkedHashSet[A] =>
+        val iter = lhs.entryIterator
         while (iter.hasNext) {
           val next = iter.next()
           addElem(next.key, next.hash)
@@ -127,6 +134,14 @@ final class HashSet[A](initialCapacity: Int, loadFactor: Double)
           if (size == 0) return this
         }
         this
+      case lhs: mutable.LinkedHashSet[A] =>
+        val iter = lhs.entryIterator
+        while (iter.hasNext) {
+          val next = iter.next()
+          remove(next.key, next.hash)
+          if (size == 0) return this
+        }
+        this
       case _ => super.subtractAll(xs)
     }
   }
diff --git a/library/src/scala/collection/mutable/LinkedHashMap.scala b/library/src/scala/collection/mutable/LinkedHashMap.scala
@@ -16,6 +16,7 @@ package mutable
 
 import scala.annotation.{nowarn, tailrec}
 import scala.collection.generic.DefaultSerializable
+import scala.util.hashing.MurmurHash3
 
 
 /** This class implements mutable maps using a hashtable.
@@ -90,6 +91,10 @@ class LinkedHashMap[K, V]
     if (e == null) None
     else Some(e.value)
   }
+  override def sizeHint(size: Int): Unit = {
+    val target = tableSizeFor(((size + 1).toDouble / LinkedHashMap.defaultLoadFactor).toInt)
+    if(target > table.length) growTable(target)
+  }
 
   override def contains(key: K): Boolean = {
     if (getClass eq classOf[LinkedHashMap[_, _]])
@@ -110,6 +115,41 @@ class LinkedHashMap[K, V]
     case nd => Some(nd.value)
   }
 
+  override def getOrElse[V1 >: V](key: K, default: => V1): V1 = {
+    if (getClass != classOf[LinkedHashMap[_, _]]) {
+      // subclasses of LinkedHashMap might customise `get` ...
+      super.getOrElse(key, default)
+    } else {
+      // .. but in the common case, we can avoid the Option boxing.
+      val nd = findEntry(key)
+      if (nd eq null) default else nd.value
+    }
+  }
+
+  override def getOrElseUpdate(key: K, defaultValue: => V): V = {
+    if (getClass != classOf[LinkedHashMap[_, _]]) {
+      // subclasses of LinkedHashMap might customise `get` ...
+      super.getOrElseUpdate(key, defaultValue)
+    } else {
+          val hash = computeHash(key)
+          val idx = index(hash)
+          val nd = table(idx) match {
+            case null => null
+            case nd => nd.findEntry(key, hash)
+          }
+          if (nd != null) nd.value
+          else {
+            val table0 = table
+            val default = defaultValue
+            if (contentSize + 1 >= threshold) growTable(table.length * 2)
+            // Avoid recomputing index if the `defaultValue()` or new element hasn't triggered a table resize.
+            val newIdx = if (table0 eq table) idx else index(hash)
+            put0(key, default, false, hash, newIdx)
+            default
+          }
+        }
+  }
+
   private[this] def removeEntry0(elem: K): Entry = removeEntry0(elem, computeHash(elem))
 
   /** Removes a key from this map if it exists
@@ -150,6 +190,7 @@ class LinkedHashMap[K, V]
   @`inline` private[this] def improveHash(originalHash: Int): Int = {
     originalHash ^ (originalHash >>> 16)
   }
+  @`inline` private[collection] def unimproveHash(improvedHash: Int): Int = improveHash(improvedHash)
 
   /** Computes the improved hash of this key */
   @`inline` private[this] def computeHash(o: K): Int = improveHash(o.##)
@@ -196,57 +237,73 @@ class LinkedHashMap[K, V]
       else Iterator.empty.next()
   }
 
+  private[collection] def entryIterator: Iterator[Entry] = new AbstractIterator[Entry] {
+    private[this] var cur = firstEntry
+
+    def hasNext = cur ne null
+
+    def next() =
+      if (hasNext) {
+        val res = cur; cur = cur.later; res
+      }
+      else Iterator.empty.next()
+  }
   // Override updateWith for performance, so we can do the update while hashing
   // the input key only once and performing one lookup into the hash table
   override def updateWith(key: K)(remappingFunction: Option[V] => Option[V]): Option[V] = {
-    val hash = computeHash(key)
-    val indexedHash = index(hash)
+    if (getClass != classOf[LinkedHashMap[_, _]]) {
+      // subclasses of LinkedHashMap might customise `get` ...
+      super.updateWith(key)(remappingFunction)
+    } else {
+          val hash = computeHash(key)
+          val indexedHash = index(hash)
+
+          var foundEntry: Entry = null
+          var previousEntry: Entry = null
+          table(indexedHash) match {
+            case null =>
+            case nd =>
+              @tailrec
+              def findEntry(prev: Entry, nd: Entry, k: K, h: Int): Unit = {
+                if (h == nd.hash && k == nd.key) {
+                  previousEntry = prev
+                  foundEntry = nd
+                }
+                else if ((nd.next eq null) || (nd.hash > h)) ()
+                else findEntry(nd, nd.next, k, h)
+              }
 
-    var foundEntry: Entry = null
-    var previousEntry: Entry = null
-    table(indexedHash) match {
-      case null =>
-      case nd =>
-        @tailrec
-        def findEntry(prev: Entry, nd: Entry, k: K, h: Int): Unit = {
-          if (h == nd.hash && k == nd.key) {
-            previousEntry = prev
-            foundEntry = nd
+              findEntry(null, nd, key, hash)
           }
-          else if ((nd.next eq null) || (nd.hash > h)) ()
-          else findEntry(nd, nd.next, k, h)
-        }
-
-        findEntry(null, nd, key, hash)
-    }
 
-    val previousValue = foundEntry match {
-      case null => None
-      case nd => Some(nd.value)
-    }
+          val previousValue = foundEntry match {
+            case null => None
+            case nd => Some(nd.value)
+          }
 
-    val nextValue = remappingFunction(previousValue)
+          val nextValue = remappingFunction(previousValue)
 
-    (previousValue, nextValue) match {
-      case (None, None) => // do nothing
+          (previousValue, nextValue) match {
+            case (None, None) => // do nothing
 
-      case (Some(_), None) =>
-        if (previousEntry != null) previousEntry.next = foundEntry.next
-        else table(indexedHash) = foundEntry.next
-        deleteEntry(foundEntry)
-        contentSize -= 1
+            case (Some(_), None) =>
+              if (previousEntry != null) previousEntry.next = foundEntry.next
+              else table(indexedHash) = foundEntry.next
+              deleteEntry(foundEntry)
+              contentSize -= 1
 
-      case (None, Some(value)) =>
-        val newIndexedHash =
-          if (contentSize + 1 >= threshold) {
-            growTable(table.length * 2)
-            index(hash)
-          } else indexedHash
-        put0(key, value, false, hash, newIndexedHash)
+            case (None, Some(value)) =>
+              val newIndexedHash =
+                if (contentSize + 1 >= threshold) {
+                  growTable(table.length * 2)
+                  index(hash)
+                } else indexedHash
+              put0(key, value, false, hash, newIndexedHash)
 
-      case (Some(_), Some(newValue)) => foundEntry.value = newValue
+            case (Some(_), Some(newValue)) => foundEntry.value = newValue
+          }
+          nextValue
     }
-    nextValue
   }
 
   override def valuesIterator: Iterator[V] = new AbstractIterator[V] {
@@ -257,6 +314,7 @@ class LinkedHashMap[K, V]
       else Iterator.empty.next()
   }
 
+
   override def foreach[U](f: ((K, V)) => U): Unit = {
     var cur = firstEntry
     while (cur ne null) {
@@ -394,6 +452,33 @@ class LinkedHashMap[K, V]
     }
   }
 
+  override def hashCode(): Int = {
+    abstract class LinkedHashMapIterator[A](val firstentry: Entry) extends AbstractIterator[A] {
+    var cur = firstentry
+    def extract(nd: Entry): A
+    def hasNext: Boolean =  cur ne null
+    def next(): A =
+      if(hasNext) {
+        val r = extract(cur)
+        cur = cur.later
+        r
+      } else Iterator.empty.next()
+    }
+
+    if (isEmpty) MurmurHash3.emptyMapHash
+    else {
+      val tupleHashIterator = new LinkedHashMapIterator[Any](firstEntry) {
+        var hash: Int = 0
+        override def hashCode: Int = hash
+        override  def extract(nd: Entry): Any = {
+          hash = MurmurHash3.tuple2Hash(unimproveHash(nd.hash), nd.value.##)
+          this
+        }
+      }
+
+      MurmurHash3.orderedHash(tupleHashIterator, MurmurHash3.mapSeed)
+    }
+  }
   @nowarn("""cat=deprecation&origin=scala\.collection\.Iterable\.stringPrefix""")
   override protected[this] def stringPrefix = "LinkedHashMap"
 }
diff --git a/library/src/scala/collection/mutable/LinkedHashSet.scala b/library/src/scala/collection/mutable/LinkedHashSet.scala
