Support building project with JDK_6

Author: Abduqodiri Qurbonzoda

kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableMap/PersistentHashMapBuilder.kt

@@ -75,6 +75,13 @@ internal class PersistentHashMapBuilder<K, V>(private var map: PersistentHashMap
         return operationResult
     }
 
+    fun remove(key: K, value: V): Boolean {
+        val oldSize = size
+        val keyHash = key?.hashCode() ?: NULL_HASH_CODE
+        node = node.mutableRemove(keyHash, key, value, 0, this) ?: TrieNode.EMPTY as TrieNode<K, V>
+        return oldSize != size
+    }
+
     override fun clear() {
         node = TrieNode.EMPTY as TrieNode<K, V>
         size = 0

kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableMap/TrieNode.kt

@@ -194,6 +194,7 @@ internal class TrieNode<K, V>(var dataMap: Int,
 
     private fun mutableRemoveDataAtIndex(keyIndex: Int, position: Int, mutator: PersistentHashMapBuilder<K, V>): TrieNode<K, V>? {
 //        assert(hasDataAt(position))
+        mutator.size--
         mutator.operationResult = buffer[keyIndex + 1] as V
         if (buffer.size == 2) { return null }
 
@@ -214,6 +215,7 @@ internal class TrieNode<K, V>(var dataMap: Int,
     }
 
     private fun mutableCollisionRemoveDataAtIndex(i: Int, mutator: PersistentHashMapBuilder<K, V>): TrieNode<K, V>? {
+        mutator.size--
         mutator.operationResult = buffer[i + 1] as V
         if (buffer.size == 2) { return null }
 
@@ -315,7 +317,6 @@ internal class TrieNode<K, V>(var dataMap: Int,
     private fun mutableCollisionRemove(key: K, mutator: PersistentHashMapBuilder<K, V>): TrieNode<K, V>? {
         for (i in 0 until buffer.size step ENTRY_SIZE) {
             if (key == buffer[i]) {
-                mutator.size--
                 return mutableCollisionRemoveDataAtIndex(i, mutator)
             }
         }
@@ -331,6 +332,15 @@ internal class TrieNode<K, V>(var dataMap: Int,
         return this
     }
 
+    private fun mutableCollisionRemove(key: K, value: V, mutator: PersistentHashMapBuilder<K, V>): TrieNode<K, V>? {
+        for (i in 0 until buffer.size step ENTRY_SIZE) {
+            if (key == buffer[i] && value == buffer[i + 1]) {
+                return mutableCollisionRemoveDataAtIndex(i, mutator)
+            }
+        }
+        return this
+    }
+
     fun containsKey(keyHash: Int, key: K, shift: Int): Boolean {
         val keyPosition = 1 shl ((keyHash shr shift) and MAX_BRANCHING_FACTOR_MINUS_ONE)
 
@@ -472,7 +482,6 @@ internal class TrieNode<K, V>(var dataMap: Int,
             val keyIndex = keyDataIndex(keyPosition)
 
             if (key == keyAtIndex(keyIndex)) {
-                mutator.size--
                 return mutableRemoveDataAtIndex(keyIndex, keyPosition, mutator)
             }
             return this
@@ -524,6 +533,35 @@ internal class TrieNode<K, V>(var dataMap: Int,
         return this
     }
 
+    fun mutableRemove(keyHash: Int, key: K, value: @UnsafeVariance V, shift: Int, mutator: PersistentHashMapBuilder<K, V>): TrieNode<K, V>? {
+        val keyPosition = 1 shl ((keyHash shr shift) and MAX_BRANCHING_FACTOR_MINUS_ONE)
+
+        if (hasDataAt(keyPosition)) { // key is directly in buffer
+            val keyIndex = keyDataIndex(keyPosition)
+
+            if (key == keyAtIndex(keyIndex) && value == valueAtKeyIndex(keyIndex)) {
+                return mutableRemoveDataAtIndex(keyIndex, keyPosition, mutator)
+            }
+            return this
+        }
+        if (hasNodeAt(keyPosition)) { // key is in node
+            val nodeIndex = keyNodeIndex(keyPosition)
+
+            val targetNode = nodeAtIndex(nodeIndex)
+            val newNode = if (shift == MAX_SHIFT) {
+                targetNode.mutableCollisionRemove(key, value, mutator)
+            } else {
+                targetNode.mutableRemove(keyHash, key, value, shift + LOG_MAX_BRANCHING_FACTOR, mutator)
+            }
+            if (targetNode === newNode) { return this }
+            if (newNode == null) { return mutableRemoveNodeAtIndex(nodeIndex, keyPosition, mutator.marker) }
+            return mutableUpdateNodeAtIndex(nodeIndex, newNode, mutator.marker)
+        }
+
+        // key is absent
+        return this
+    }
+
     internal companion object {
         internal val EMPTY = TrieNode<Nothing, Nothing>(0, 0, emptyArray())
     }

kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/persistentOrderedMap/PersistentOrderedMapBuilder.kt

@@ -105,6 +105,17 @@ internal class PersistentOrderedMapBuilder<K, V>(private var map: PersistentOrde
         return links.value
     }
 
+    fun remove(key: K, value: V): Boolean {
+        val links = mapBuilder[key] ?: return false
+
+        return if (links.value != value) {
+            false
+        } else {
+            remove(key)
+            true
+        }
+    }
+
     override fun clear() {
         mapBuilder.clear()
         firstKey = null

kotlinx-collections-immutable/tests/src/test/kotlin/kotlinx.collections.immutable/stressTests/WrapperGenerator.kt

@@ -32,14 +32,14 @@ class WrapperGenerator<K: Comparable<K>>(private val hashCodeUpperBound: Int) {
         val wrapper = ObjectWrapper(element, hashCode)
         elementMap[element] = wrapper
 
-        val wrappers = hashCodeMap.getOrDefault(hashCode, mutableListOf())
+        val wrappers = hashCodeMap[hashCode] ?: mutableListOf()
         wrappers.add(wrapper)
         hashCodeMap[hashCode] = wrappers
 
         return wrapper
     }
 
     fun wrappersByHashCode(hashCode: Int): List<ObjectWrapper<K>> {
-        return hashCodeMap.getOrDefault(hashCode, mutableListOf())
+        return hashCodeMap[hashCode] ?: mutableListOf()
     }
 }