Make first/last contains either EndOfLink or instance of generic param

Abduqodiri Qurbonzoda · Abduqodiri Qurbonzoda · commit 280fdaf58d4f · 2019-04-16T02:19:42.000+03:00
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/persistentOrderedMap/PersistentOrderedMap.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/persistentOrderedMap/PersistentOrderedMap.kt
@@ -37,8 +37,8 @@ internal class LinkedValue<V>(val value: V, val previous: Any?, val next: Any?)
     }
 }
 
-internal class PersistentOrderedMap<K, V>(internal val firstKey: K?,
-                                          internal val lastKey: K?,
+internal class PersistentOrderedMap<K, V>(internal val firstKey: Any?,
+                                          internal val lastKey: Any?,
                                           internal val map: PersistentHashMap<K, LinkedValue<V>>): AbstractMap<K, V>(), PersistentMap<K, V> {
 
     override val size: Int
@@ -78,6 +78,11 @@ internal class PersistentOrderedMap<K, V>(internal val firstKey: K?,
     }
 
     override fun put(key: K, value: @UnsafeVariance V): PersistentOrderedMap<K, V> {
+        if (isEmpty()) {
+            val newMap = map.put(key, LinkedValue(value))
+            return PersistentOrderedMap(key, key, newMap)
+        }
+
         val links = map[key]
         if (links != null) {
             if (links.value == value) {
@@ -86,10 +91,7 @@ internal class PersistentOrderedMap<K, V>(internal val firstKey: K?,
             val newMap = map.put(key, links.withValue(value))
             return PersistentOrderedMap(firstKey, lastKey, newMap)
         }
-        if (isEmpty()) {
-            val newMap = map.put(key, LinkedValue(value))
-            return PersistentOrderedMap(key, key, newMap)
-        }
+
         val lastLink = map[lastKey]!!
 //        assert(lastLink.next === EndOfLink)
         val newMap = map
@@ -112,8 +114,9 @@ internal class PersistentOrderedMap<K, V>(internal val firstKey: K?,
 //            assert(nextLinks.previous == key)
             newMap = newMap.put(links.next as K, nextLinks.withPrevious(links.previous))
         }
-        val newFirstKey = if (links.previous === EndOfLink) links.next as? K else firstKey
-        val newLastKey = if (links.next === EndOfLink) links.previous as? K else lastKey
+
+        val newFirstKey = if (links.previous === EndOfLink) links.next else firstKey
+        val newLastKey = if (links.next === EndOfLink) links.previous else lastKey
         return PersistentOrderedMap(newFirstKey, newLastKey, newMap)
     }
 
@@ -135,7 +138,7 @@ internal class PersistentOrderedMap<K, V>(internal val firstKey: K?,
     }
 
     internal companion object {
-        private val EMPTY = PersistentOrderedMap<Nothing, Nothing>(null, null, PersistentHashMap.emptyOf())
+        private val EMPTY = PersistentOrderedMap<Nothing, Nothing>(EndOfLink, EndOfLink, PersistentHashMap.emptyOf())
         internal fun <K, V> emptyOf(): PersistentOrderedMap<K, V> = EMPTY as PersistentOrderedMap<K, V>
     }
 }
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/persistentOrderedMap/PersistentOrderedMapBuilder.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/persistentOrderedMap/PersistentOrderedMapBuilder.kt
@@ -94,15 +94,16 @@ internal class PersistentOrderedMapBuilder<K, V>(private var map: PersistentOrde
 //            assert(previousLinks.next == key)
             mapBuilder[links.previous as K] = previousLinks.withNext(links.next)
         } else {
-            firstKey = links.next as? K
+            firstKey = links.next
         }
         if (links.next !== EndOfLink) {
             val nextLinks = mapBuilder[links.next]!!
 //            assert(nextLinks.previous == key)
             mapBuilder[links.next as K] = nextLinks.withPrevious(links.previous)
         } else {
-            lastKey = links.previous as? K
+            lastKey = links.previous
         }
+
         return links.value
     }
 
@@ -119,7 +120,7 @@ internal class PersistentOrderedMapBuilder<K, V>(private var map: PersistentOrde
 
     override fun clear() {
         mapBuilder.clear()
-        firstKey = null
-        lastKey = null
+        firstKey = EndOfLink
+        lastKey = EndOfLink
     }
 }
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/persistentOrderedMap/PersistentOrderedMapBuilderContentIterators.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/persistentOrderedMap/PersistentOrderedMapBuilderContentIterators.kt
@@ -19,11 +19,11 @@ package kotlinx.collections.immutable.implementations.persistentOrderedMap
 import kotlinx.collections.immutable.implementations.immutableMap.MapEntry
 
 internal open class PersistentOrderedMapBuilderLinksIterator<K, V>(
-        private var nextKey: K?,
+        private var nextKey: Any?,
         internal val builder: PersistentOrderedMapBuilder<K, V>
 ) : MutableIterator<LinkedValue<V>> {
 
-    internal var lastIteratedKey: K? = null
+    internal var lastIteratedKey: Any? = EndOfLink
     private var nextWasInvoked = false
     private var expectedModCount = builder.mapBuilder.modCount
     internal var index = 0
@@ -39,7 +39,7 @@ internal open class PersistentOrderedMapBuilderLinksIterator<K, V>(
         nextWasInvoked = true
         index++
         val result = builder.mapBuilder[nextKey]!!
-        nextKey = result.next as? K
+        nextKey = result.next
         return result
     }
 
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/persistentOrderedMap/PersistentOrderedMapContentIterators.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/persistentOrderedMap/PersistentOrderedMapContentIterators.kt
@@ -18,7 +18,7 @@ package kotlinx.collections.immutable.implementations.persistentOrderedMap
 
 import kotlinx.collections.immutable.implementations.immutableMap.MapEntry
 
-internal open class PersistentOrderedMapLinksIterator<K, V>(internal var nextKey: K?,
+internal open class PersistentOrderedMapLinksIterator<K, V>(internal var nextKey: Any?,
                                                             internal val map: Map<K, LinkedValue<V>>) : Iterator<LinkedValue<V>> {
     internal var index = 0
 
@@ -32,7 +32,7 @@ internal open class PersistentOrderedMapLinksIterator<K, V>(internal var nextKey
         }
         val result = map[nextKey]!!
         index++
-        nextKey = result.next as? K
+        nextKey = result.next
         return result
     }
 
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/persistentOrderedSet/PersistentOrderedSet.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/persistentOrderedSet/PersistentOrderedSet.kt
@@ -33,8 +33,8 @@ internal class Links(val previous: Any?, val next: Any?) {
     }
 }
 
-internal class PersistentOrderedSet<E>(internal val firstElement: E?,
-                                       internal val lastElement: E?,
+internal class PersistentOrderedSet<E>(internal val firstElement: Any?,
+                                       internal val lastElement: Any?,
                                        internal val map: PersistentHashMap<E, Links>): AbstractSet<E>(), PersistentSet<E> {
 
     override val size: Int
@@ -48,7 +48,7 @@ internal class PersistentOrderedSet<E>(internal val firstElement: E?,
         if (map.containsKey(element)) {
             return this
         }
-        if (isEmpty()) {  //  isEmpty
+        if (isEmpty()) {
             val newMap = map.put(element, Links())
             return PersistentOrderedSet(element, element, newMap)
         }
@@ -79,8 +79,8 @@ internal class PersistentOrderedSet<E>(internal val firstElement: E?,
 //            assert(nextLinks.previous == element)
             newMap = newMap.put(links.next as E, nextLinks.withPrevious(links.previous))
         }
-        val newFirstElement = if (links.previous === EndOfLink) links.next as? E else firstElement
-        val newLastElement = if (links.next === EndOfLink) links.previous as? E else lastElement
+        val newFirstElement = if (links.previous === EndOfLink) links.next else firstElement
+        val newLastElement = if (links.next === EndOfLink) links.previous else lastElement
         return PersistentOrderedSet(newFirstElement, newLastElement, newMap)
     }
 
@@ -105,7 +105,7 @@ internal class PersistentOrderedSet<E>(internal val firstElement: E?,
     }
 
     internal companion object {
-        private val EMPTY = PersistentOrderedSet(null, null, PersistentHashMap.emptyOf())
+        private val EMPTY = PersistentOrderedSet<Nothing>(EndOfLink, EndOfLink, PersistentHashMap.emptyOf())
         internal fun <E> emptyOf(): PersistentSet<E> = EMPTY
     }
 }
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/persistentOrderedSet/PersistentOrderedSetBuilder.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/persistentOrderedSet/PersistentOrderedSetBuilder.kt
@@ -47,18 +47,19 @@ internal class PersistentOrderedSetBuilder<E>(private var set: PersistentOrdered
         if (mapBuilder.containsKey(element)) {
             return false
         }
-        if (isEmpty()) {  //  isEmpty
+        if (isEmpty()) {
             firstElement = element
             lastElement = element
             mapBuilder[element] = Links()
             return true
         }
+
         val lastLinks = mapBuilder[lastElement]!!
 //        assert(lastLinks.next === EndOfLink)
-
         mapBuilder[lastElement as E] = lastLinks.withNext(element)
         mapBuilder[element] = lastLinks.putNextLink(lastElement)
         lastElement = element
+
         return true
     }
 
@@ -70,22 +71,23 @@ internal class PersistentOrderedSetBuilder<E>(private var set: PersistentOrdered
 //            assert(previousLinks.next == element)
             mapBuilder[links.previous as E] = previousLinks.withNext(links.next)
         } else {
-            firstElement = links.next as? E
+            firstElement = links.next
         }
         if (links.next !== EndOfLink) {
             val nextLinks = mapBuilder[links.next]!!
 //            assert(nextLinks.previous == element)
             mapBuilder[links.next as E] = nextLinks.withPrevious(links.previous)
         } else {
-            lastElement = links.previous as? E
+            lastElement = links.previous
         }
+
         return true
     }
 
     override fun clear() {
         mapBuilder.clear()
-        firstElement = null
-        lastElement = null
+        firstElement = EndOfLink
+        lastElement = EndOfLink
     }
 
     override fun iterator(): MutableIterator<E> {
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/persistentOrderedSet/PersistentOrderedSetIterator.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/persistentOrderedSet/PersistentOrderedSetIterator.kt
@@ -16,7 +16,7 @@
 
 package kotlinx.collections.immutable.implementations.persistentOrderedSet
 
-internal open class PersistentOrderedSetIterator<E>(private var nextElement: E?,
+internal open class PersistentOrderedSetIterator<E>(private var nextElement: Any?,
                                                     internal val map: Map<E, Links>) : Iterator<E> {
     internal var index = 0
 
@@ -29,7 +29,7 @@ internal open class PersistentOrderedSetIterator<E>(private var nextElement: E?,
 
         val result = nextElement as E
         index++
-        nextElement = map[result]!!.next as? E
+        nextElement = map[result]!!.next
         return result
     }
 

Original file line number	Diff line number	Diff line change
`@@ -37,8 +37,8 @@ internal class LinkedValue<V>(val value: V, val previous: Any?, val next: Any?)`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`
`40`		`-internal class PersistentOrderedMap<K, V>(internal val firstKey: K?,`
`41`		`- internal val lastKey: K?,`
	`40`	`+internal class PersistentOrderedMap<K, V>(internal val firstKey: Any?,`
	`41`	`+ internal val lastKey: Any?,`
`42`	`42`	`internal val map: PersistentHashMap<K, LinkedValue<V>>): AbstractMap<K, V>(), PersistentMap<K, V> {`
`43`	`43`
`44`	`44`	`override val size: Int`
`@@ -78,6 +78,11 @@ internal class PersistentOrderedMap<K, V>(internal val firstKey: K?,`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`override fun put(key: K, value: @UnsafeVariance V): PersistentOrderedMap<K, V> {`
	`81`	`+ if (isEmpty()) {`
	`82`	`+ val newMap = map.put(key, LinkedValue(value))`
	`83`	`+ return PersistentOrderedMap(key, key, newMap)`
	`84`	`+ }`
	`85`	`+`
`81`	`86`	`val links = map[key]`
`82`	`87`	`if (links != null) {`
`83`	`88`	`if (links.value == value) {`
`@@ -86,10 +91,7 @@ internal class PersistentOrderedMap<K, V>(internal val firstKey: K?,`
`86`	`91`	`val newMap = map.put(key, links.withValue(value))`
`87`	`92`	`return PersistentOrderedMap(firstKey, lastKey, newMap)`
`88`	`93`	`}`
`89`		`- if (isEmpty()) {`
`90`		`- val newMap = map.put(key, LinkedValue(value))`
`91`		`- return PersistentOrderedMap(key, key, newMap)`
`92`		`- }`
	`94`	`+`
`93`	`95`	`val lastLink = map[lastKey]!!`
`94`	`96`	`// assert(lastLink.next === EndOfLink)`
`95`	`97`	`val newMap = map`
`@@ -112,8 +114,9 @@ internal class PersistentOrderedMap<K, V>(internal val firstKey: K?,`
`112`	`114`	`// assert(nextLinks.previous == key)`
`113`	`115`	`newMap = newMap.put(links.next as K, nextLinks.withPrevious(links.previous))`
`114`	`116`	`}`
`115`		`- val newFirstKey = if (links.previous === EndOfLink) links.next as? K else firstKey`
`116`		`- val newLastKey = if (links.next === EndOfLink) links.previous as? K else lastKey`
	`117`	`+`
	`118`	`+ val newFirstKey = if (links.previous === EndOfLink) links.next else firstKey`
	`119`	`+ val newLastKey = if (links.next === EndOfLink) links.previous else lastKey`
`117`	`120`	`return PersistentOrderedMap(newFirstKey, newLastKey, newMap)`
`118`	`121`	`}`
`119`	`122`
`@@ -135,7 +138,7 @@ internal class PersistentOrderedMap<K, V>(internal val firstKey: K?,`
`135`	`138`	`}`
`136`	`139`
`137`	`140`	`internal companion object {`
`138`		`- private val EMPTY = PersistentOrderedMap<Nothing, Nothing>(null, null, PersistentHashMap.emptyOf())`
	`141`	`+ private val EMPTY = PersistentOrderedMap<Nothing, Nothing>(EndOfLink, EndOfLink, PersistentHashMap.emptyOf())`
`139`	`142`	`internal fun <K, V> emptyOf(): PersistentOrderedMap<K, V> = EMPTY as PersistentOrderedMap<K, V>`
`140`	`143`	`}`
`141`	`144`	`}`
Original file line number	Diff line number	Diff line change
`@@ -94,15 +94,16 @@ internal class PersistentOrderedMapBuilder<K, V>(private var map: PersistentOrde`
`94`	`94`	`// assert(previousLinks.next == key)`
`95`	`95`	`mapBuilder[links.previous as K] = previousLinks.withNext(links.next)`
`96`	`96`	`} else {`
`97`		`- firstKey = links.next as? K`
	`97`	`+ firstKey = links.next`
`98`	`98`	`}`
`99`	`99`	`if (links.next !== EndOfLink) {`
`100`	`100`	`val nextLinks = mapBuilder[links.next]!!`
`101`	`101`	`// assert(nextLinks.previous == key)`
`102`	`102`	`mapBuilder[links.next as K] = nextLinks.withPrevious(links.previous)`
`103`	`103`	`} else {`
`104`		`- lastKey = links.previous as? K`
	`104`	`+ lastKey = links.previous`
`105`	`105`	`}`
	`106`	`+`
`106`	`107`	`return links.value`
`107`	`108`	`}`
`108`	`109`
`@@ -119,7 +120,7 @@ internal class PersistentOrderedMapBuilder<K, V>(private var map: PersistentOrde`
`119`	`120`
`120`	`121`	`override fun clear() {`
`121`	`122`	`mapBuilder.clear()`
`122`		`- firstKey = null`
`123`		`- lastKey = null`
	`123`	`+ firstKey = EndOfLink`
	`124`	`+ lastKey = EndOfLink`
`124`	`125`	`}`
`125`	`126`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ package kotlinx.collections.immutable.implementations.persistentOrderedMap`
`18`	`18`
`19`	`19`	`import kotlinx.collections.immutable.implementations.immutableMap.MapEntry`
`20`	`20`
`21`		`-internal open class PersistentOrderedMapLinksIterator<K, V>(internal var nextKey: K?,`
	`21`	`+internal open class PersistentOrderedMapLinksIterator<K, V>(internal var nextKey: Any?,`
`22`	`22`	`internal val map: Map<K, LinkedValue<V>>) : Iterator<LinkedValue<V>> {`
`23`	`23`	`internal var index = 0`
`24`	`24`
`@@ -32,7 +32,7 @@ internal open class PersistentOrderedMapLinksIterator<K, V>(internal var nextKey`
`32`	`32`	`}`
`33`	`33`	`val result = map[nextKey]!!`
`34`	`34`	`index++`
`35`		`- nextKey = result.next as? K`
	`35`	`+ nextKey = result.next`
`36`	`36`	`return result`
`37`	`37`	`}`
`38`	`38`
Original file line number	Diff line number	Diff line change
`@@ -33,8 +33,8 @@ internal class Links(val previous: Any?, val next: Any?) {`
`33`	`33`	`}`
`34`	`34`	`}`
`35`	`35`
`36`		`-internal class PersistentOrderedSet<E>(internal val firstElement: E?,`
`37`		`- internal val lastElement: E?,`
	`36`	`+internal class PersistentOrderedSet<E>(internal val firstElement: Any?,`
	`37`	`+ internal val lastElement: Any?,`
`38`	`38`	`internal val map: PersistentHashMap<E, Links>): AbstractSet<E>(), PersistentSet<E> {`
`39`	`39`
`40`	`40`	`override val size: Int`
`@@ -48,7 +48,7 @@ internal class PersistentOrderedSet<E>(internal val firstElement: E?,`
`48`	`48`	`if (map.containsKey(element)) {`
`49`	`49`	`return this`
`50`	`50`	`}`
`51`		`- if (isEmpty()) { // isEmpty`
	`51`	`+ if (isEmpty()) {`
`52`	`52`	`val newMap = map.put(element, Links())`
`53`	`53`	`return PersistentOrderedSet(element, element, newMap)`
`54`	`54`	`}`
`@@ -79,8 +79,8 @@ internal class PersistentOrderedSet<E>(internal val firstElement: E?,`
`79`	`79`	`// assert(nextLinks.previous == element)`
`80`	`80`	`newMap = newMap.put(links.next as E, nextLinks.withPrevious(links.previous))`
`81`	`81`	`}`
`82`		`- val newFirstElement = if (links.previous === EndOfLink) links.next as? E else firstElement`
`83`		`- val newLastElement = if (links.next === EndOfLink) links.previous as? E else lastElement`
	`82`	`+ val newFirstElement = if (links.previous === EndOfLink) links.next else firstElement`
	`83`	`+ val newLastElement = if (links.next === EndOfLink) links.previous else lastElement`
`84`	`84`	`return PersistentOrderedSet(newFirstElement, newLastElement, newMap)`
`85`	`85`	`}`
`86`	`86`
`@@ -105,7 +105,7 @@ internal class PersistentOrderedSet<E>(internal val firstElement: E?,`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`internal companion object {`
`108`		`- private val EMPTY = PersistentOrderedSet(null, null, PersistentHashMap.emptyOf())`
	`108`	`+ private val EMPTY = PersistentOrderedSet<Nothing>(EndOfLink, EndOfLink, PersistentHashMap.emptyOf())`
`109`	`109`	`internal fun <E> emptyOf(): PersistentSet<E> = EMPTY`
`110`	`110`	`}`
`111`	`111`	`}`