Build new persistent instance only if new changes are applied

Abdukodiri Kurbonzoda · Abduqodiri Qurbonzoda · commit 5402dd37c379 · 2019-03-22T03:05:37.000+03:00
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableList/PersistentVector.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableList/PersistentVector.kt
@@ -201,7 +201,7 @@ internal class PersistentVector<E>(private val root: Array<Any?>,
     }
 
     override fun builder(): PersistentList.Builder<E> {
-        return PersistentVectorBuilder(root, tail, size, shiftStart)
+        return PersistentVectorBuilder(this, root, tail, shiftStart)
     }
 
     override fun listIterator(index: Int): ListIterator<E> {
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableList/PersistentVectorBuilder.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableList/PersistentVectorBuilder.kt
@@ -20,21 +20,33 @@ import kotlinx.collections.immutable.PersistentList
 
 private class Marker
 
-class PersistentVectorBuilder<E>(private var root: Array<Any?>?,
-                                 private var tail: Array<Any?>?,
-                                 override var size: Int,
+class PersistentVectorBuilder<E>(private var vector: PersistentList<E>,
+                                 private var vectorRoot: Array<Any?>?,
+                                 private var vectorTail: Array<Any?>,
                                  private var shiftStart: Int) : AbstractMutableList<E>(), PersistentList.Builder<E> {
     private var marker = Marker()
+    private var root = vectorRoot
+    private var tail = vectorTail
+    override var size = vector.size
 
     override fun build(): PersistentList<E> {
-        marker = Marker()
-        if (root == null) {
-            if (tail == null) {
-                return persistentVectorOf()
+        vector = if (root === vectorRoot && tail === vectorTail) {
+            vector
+        } else {
+            marker = Marker()
+            vectorRoot = root
+            vectorTail = tail
+            if (root == null) {
+                if (tail.isEmpty()) {
+                    persistentVectorOf()
+                } else {
+                    SmallPersistentVector(tail.copyOf(size))
+                }
+            } else {
+                PersistentVector(root!!, tail, size, shiftStart)
             }
-            return SmallPersistentVector(tail!!.copyOf(size))
         }
-        return PersistentVector(root!!, tail!!, size, shiftStart)
+        return vector
     }
 
     private fun rootSize(): Int {
@@ -71,13 +83,13 @@ class PersistentVectorBuilder<E>(private var root: Array<Any?>?,
 
         val tailSize = size - rootSize()
         if (tailSize < MAX_BUFFER_SIZE) {
-            val mutableLast = makeMutable(tail)
-            mutableLast[tailSize] = element
-            this.tail = mutableLast
+            val mutableTail = makeMutable(tail)
+            mutableTail[tailSize] = element
+            this.tail = mutableTail
             this.size += 1
         } else {
             val newTail = mutableBufferWith(element)
-            this.pushFullTail(root, tail!!, newTail)
+            this.pushFullTail(root, tail, newTail)
         }
         return true
     }
@@ -149,7 +161,7 @@ class PersistentVectorBuilder<E>(private var root: Array<Any?>?,
             this.tail = mutableTail
             this.size += 1
         } else {
-            val lastElement = tail!![MAX_BUFFER_SIZE_MINUS_ONE]
+            val lastElement = tail[MAX_BUFFER_SIZE_MINUS_ONE]
             System.arraycopy(tail, index, mutableTail, index + 1, MAX_BUFFER_SIZE_MINUS_ONE - index)
             mutableTail[index] = element
             pushFullTail(root, mutableTail, mutableBufferWith(lastElement))
@@ -190,7 +202,7 @@ class PersistentVectorBuilder<E>(private var root: Array<Any?>?,
 
     private fun bufferFor(index: Int): Array<Any?> {
         if (rootSize() <= index) {
-            return tail!!
+            return tail
         }
         var buffer = root!!
         var shift = shiftStart
@@ -211,28 +223,28 @@ class PersistentVectorBuilder<E>(private var root: Array<Any?>?,
         if (index >= rootSize) {
             return removeFromTail(root, rootSize, shiftStart, index - rootSize) as E
         }
-        val lastElementWrapper = ObjectWrapper(tail!![0])
+        val lastElementWrapper = ObjectWrapper(tail[0])
         val newRoot = removeFromRoot(root!!, shiftStart, index, lastElementWrapper)
         removeFromTail(newRoot, rootSize, shiftStart, 0)
         return lastElementWrapper.value as E
     }
 
     private fun removeFromTail(root: Array<Any?>?, rootSize: Int, shift: Int, index: Int): Any? {
-        val lastFilledSize = size - rootSize
-        assert(index < lastFilledSize)
+        val tailFilledSize = size - rootSize
+        assert(index < tailFilledSize)
 
         val removedElement: Any?
-        if (lastFilledSize == 1) {
-            removedElement = tail!![0]
+        if (tailFilledSize == 1) {
+            removedElement = tail[0]
             pullLastBufferFromRoot(root, rootSize, shift)
         } else {
-            removedElement = tail!![index]
-            val mutableLast = makeMutable(tail)
-            System.arraycopy(tail, index + 1, mutableLast, index, lastFilledSize - index - 1)
-            mutableLast[lastFilledSize - 1] = null as E
+            removedElement = tail[index]
+            val mutableTail = makeMutable(tail)
+            System.arraycopy(tail, index + 1, mutableTail, index, tailFilledSize - index - 1)
+            mutableTail[tailFilledSize - 1] = null as E
             this.root = root
-            this.tail = mutableLast
-            this.size = rootSize + lastFilledSize - 1
+            this.tail = mutableTail
+            this.size = rootSize + tailFilledSize - 1
             this.shiftStart = shift
         }
         return removedElement
@@ -268,7 +280,7 @@ class PersistentVectorBuilder<E>(private var root: Array<Any?>?,
     private fun pullLastBufferFromRoot(root: Array<Any?>?, rootSize: Int, shift: Int) {
         if (shift == 0) {
             this.root = null
-            this.tail = root
+            this.tail = root ?: emptyArray()
             this.size = rootSize
             this.shiftStart = shift
             return
@@ -313,10 +325,10 @@ class PersistentVectorBuilder<E>(private var root: Array<Any?>?,
             throw IndexOutOfBoundsException()
         }
         if (rootSize() <= index) {
-            val mutableLast = makeMutable(tail)
-            val oldElement = mutableLast[index and MAX_BUFFER_SIZE_MINUS_ONE]
-            mutableLast[index and MAX_BUFFER_SIZE_MINUS_ONE] = element
-            this.tail = mutableLast
+            val mutableTail = makeMutable(tail)
+            val oldElement = mutableTail[index and MAX_BUFFER_SIZE_MINUS_ONE]
+            mutableTail[index and MAX_BUFFER_SIZE_MINUS_ONE] = element
+            this.tail = mutableTail
             return oldElement as E
         }
 
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableList/SmallPersistentVector.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableList/SmallPersistentVector.kt
@@ -125,7 +125,7 @@ internal class SmallPersistentVector<E>(private val buffer: Array<Any?>) : Immut
     }
 
     override fun builder(): PersistentList.Builder<E> {
-        return PersistentVectorBuilder(null, buffer, size, 0)
+        return PersistentVectorBuilder(this, null, buffer, 0)
     }
 
     override fun indexOf(element: E): Int {
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableMap/PersistentHashMap.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableMap/PersistentHashMap.kt
@@ -24,8 +24,8 @@ internal const val PUT_KEY_VALUE = 2
 internal class ModificationWrapper(var value: Int = NO_MODIFICATION)
 
 
-internal class PersistentHashMap<K, V>(val node: TrieNode<K, V>,
-                                           override val size: Int): AbstractMap<K, V>(), PersistentMap<K, V> {
+internal class PersistentHashMap<K, V>(internal val node: TrieNode<K, V>,
+                                       override val size: Int): AbstractMap<K, V>(), PersistentMap<K, V> {
 
     override val keys: ImmutableSet<K>
         get() {
@@ -96,7 +96,7 @@ internal class PersistentHashMap<K, V>(val node: TrieNode<K, V>,
     }
 
     override fun builder(): PersistentMap.Builder<K, @UnsafeVariance V> {
-        return PersistentHashMapBuilder(node, size)
+        return PersistentHashMapBuilder(this)
     }
 
     internal companion object {
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableMap/PersistentHashMapBuilder.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableMap/PersistentHashMapBuilder.kt
@@ -20,13 +20,19 @@ import kotlinx.collections.immutable.PersistentMap
 
 internal class Marker
 
-internal class PersistentHashMapBuilder<K, V>(internal var node: TrieNode<K, V>,
-                                              override var size: Int) : PersistentMap.Builder<K, V>, AbstractMutableMap<K, V>() {
+internal class PersistentHashMapBuilder<K, V>(private var map: PersistentHashMap<K, V>) : PersistentMap.Builder<K, V>, AbstractMutableMap<K, V>() {
     internal var marker = Marker()
+    internal var node = map.node
+    override var size = map.size
 
     override fun build(): PersistentMap<K, V> {
-        marker = Marker()
-        return PersistentHashMap(node, size)
+        map = if (node === map.node) {
+            map
+        } else {
+            marker = Marker()
+            PersistentHashMap(node, size)
+        }
+        return map
     }
 
     override val entries: MutableSet<MutableMap.MutableEntry<K, V>>
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableSet/PersistentHashSet.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableSet/PersistentHashSet.kt
@@ -19,7 +19,7 @@ package kotlinx.collections.immutable.implementations.immutableSet
 import kotlinx.collections.immutable.PersistentSet
 import kotlinx.collections.immutable.mutate
 
-internal class PersistentHashSet<E>(private val node: TrieNode<E>,
+internal class PersistentHashSet<E>(internal val node: TrieNode<E>,
                                     override val size: Int): AbstractSet<E>(), PersistentSet<E> {
     override fun contains(element: E): Boolean {
         val hashCode = element?.hashCode() ?: NULL_HASH_CODE
@@ -62,7 +62,7 @@ internal class PersistentHashSet<E>(private val node: TrieNode<E>,
     }
 
     override fun builder(): PersistentSet.Builder<E> {
-        return PersistentHashSetBuilder(node, size)
+        return PersistentHashSetBuilder(this)
     }
 
     internal companion object {
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableSet/PersistentHashSetBuilder.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableSet/PersistentHashSetBuilder.kt
@@ -20,13 +20,19 @@ import kotlinx.collections.immutable.PersistentSet
 
 class Marker
 
-internal class PersistentHashSetBuilder<E>(var node: TrieNode<E>,
-                                           override var size: Int) : AbstractMutableSet<E>(), PersistentSet.Builder<E> {
+internal class PersistentHashSetBuilder<E>(private var set: PersistentHashSet<E>) : AbstractMutableSet<E>(), PersistentSet.Builder<E> {
     internal var marker = Marker()
+    internal var node = set.node
+    override var size = set.size
 
     override fun build(): PersistentSet<E> {
-        marker = Marker()
-        return PersistentHashSet(node, size)
+        set = if (node === set.node) {
+            set
+        } else {
+            marker = Marker()
+            PersistentHashSet(node, size)
+        }
+        return set
     }
 
     override fun contains(element: E): Boolean {

Original file line number	Diff line number	Diff line change
`@@ -201,7 +201,7 @@ internal class PersistentVector<E>(private val root: Array<Any?>,`
`201`	`201`	`}`
`202`	`202`
`203`	`203`	`override fun builder(): PersistentList.Builder<E> {`
`204`		`- return PersistentVectorBuilder(root, tail, size, shiftStart)`
	`204`	`+ return PersistentVectorBuilder(this, root, tail, shiftStart)`
`205`	`205`	`}`
`206`	`206`
`207`	`207`	`override fun listIterator(index: Int): ListIterator<E> {`
Original file line number	Diff line number	Diff line change
`@@ -125,7 +125,7 @@ internal class SmallPersistentVector<E>(private val buffer: Array<Any?>) : Immut`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	`override fun builder(): PersistentList.Builder<E> {`
`128`		`- return PersistentVectorBuilder(null, buffer, size, 0)`
	`128`	`+ return PersistentVectorBuilder(this, null, buffer, 0)`
`129`	`129`	`}`
`130`	`130`
`131`	`131`	`override fun indexOf(element: E): Int {`
Original file line number	Diff line number	Diff line change
`@@ -24,8 +24,8 @@ internal const val PUT_KEY_VALUE = 2`
`24`	`24`	`internal class ModificationWrapper(var value: Int = NO_MODIFICATION)`
`25`	`25`
`26`	`26`
`27`		`-internal class PersistentHashMap<K, V>(val node: TrieNode<K, V>,`
`28`		`- override val size: Int): AbstractMap<K, V>(), PersistentMap<K, V> {`
	`27`	`+internal class PersistentHashMap<K, V>(internal val node: TrieNode<K, V>,`
	`28`	`+ override val size: Int): AbstractMap<K, V>(), PersistentMap<K, V> {`
`29`	`29`
`30`	`30`	`override val keys: ImmutableSet<K>`
`31`	`31`	`get() {`
`@@ -96,7 +96,7 @@ internal class PersistentHashMap<K, V>(val node: TrieNode<K, V>,`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`override fun builder(): PersistentMap.Builder<K, @UnsafeVariance V> {`
`99`		`- return PersistentHashMapBuilder(node, size)`
	`99`	`+ return PersistentHashMapBuilder(this)`
`100`	`100`	`}`
`101`	`101`
`102`	`102`	`internal companion object {`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ package kotlinx.collections.immutable.implementations.immutableSet`
`19`	`19`	`import kotlinx.collections.immutable.PersistentSet`
`20`	`20`	`import kotlinx.collections.immutable.mutate`
`21`	`21`
`22`		`-internal class PersistentHashSet<E>(private val node: TrieNode<E>,`
	`22`	`+internal class PersistentHashSet<E>(internal val node: TrieNode<E>,`
`23`	`23`	`override val size: Int): AbstractSet<E>(), PersistentSet<E> {`
`24`	`24`	`override fun contains(element: E): Boolean {`
`25`	`25`	`val hashCode = element?.hashCode() ?: NULL_HASH_CODE`
`@@ -62,7 +62,7 @@ internal class PersistentHashSet<E>(private val node: TrieNode<E>,`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`override fun builder(): PersistentSet.Builder<E> {`
`65`		`- return PersistentHashSetBuilder(node, size)`
	`65`	`+ return PersistentHashSetBuilder(this)`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`internal companion object {`