Rename Links to LinkedValue

Author: ilya-g

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

@@ -22,11 +22,11 @@ import kotlinx.collections.immutable.PersistentMap
 import kotlinx.collections.immutable.implementations.immutableMap.PersistentHashMap
 import kotlinx.collections.immutable.mutate
 
-internal class Links<out K, out V>(val value: V, val previous: K?, val next: K?)
+internal class LinkedValue<out K, out V>(val value: V, val previous: K?, val next: K?)
 
 internal class PersistentOrderedMap<K, V>(internal val firstKey: K?,
                                           internal val lastKey: K?,
-                                          internal val map: PersistentHashMap<K, Links<K, V>>): AbstractMap<K, V>(), PersistentMap<K, V> {
+                                          internal val map: PersistentHashMap<K, LinkedValue<K, V>>): AbstractMap<K, V>(), PersistentMap<K, V> {
 
     override val size: Int
         get() = map.size
@@ -70,17 +70,17 @@ internal class PersistentOrderedMap<K, V>(internal val firstKey: K?,
             if (links.value == value) {
                 return this
             }
-            val newMap = map.put(key, Links(value, links.previous, links.next))
+            val newMap = map.put(key, LinkedValue(value, links.previous, links.next))
             return PersistentOrderedMap(firstKey, lastKey, newMap)
         }
         if (isEmpty()) {
-            val newMap = map.put(key, Links(value, null, null))
+            val newMap = map.put(key, LinkedValue<K, V>(value, null, null))
             return PersistentOrderedMap(key, key, newMap)
         }
         val oldLinks = map[lastKey]!!
         assert(oldLinks.next == null)
-        val newLinks = Links(oldLinks.value, oldLinks.previous, key)
-        val newMap = map.put(lastKey as K, newLinks).put(key, Links(value, lastKey, null))
+        val newLinks = LinkedValue(oldLinks.value, oldLinks.previous, key)
+        val newMap = map.put(lastKey as K, newLinks).put(key, LinkedValue(value, lastKey, null))
         return PersistentOrderedMap(firstKey, key, newMap)
     }
 
@@ -91,12 +91,12 @@ internal class PersistentOrderedMap<K, V>(internal val firstKey: K?,
         if (key != firstKey) {
             val previousLinks = newMap[links.previous]!!
             assert(previousLinks.next == key)
-            newMap = newMap.put(links.previous as K, Links(previousLinks.value, previousLinks.previous, links.next))
+            newMap = newMap.put(links.previous as K, LinkedValue(previousLinks.value, previousLinks.previous, links.next))
         }
         if (key != lastKey) {
             val nextLinks = newMap[links.next]!!
             assert(nextLinks.previous == key)
-            newMap = newMap.put(links.next as K, Links(nextLinks.value, links.previous, nextLinks.next))
+            newMap = newMap.put(links.next as K, LinkedValue(nextLinks.value, links.previous, nextLinks.next))
         }
         val newFirstKey = if (key == firstKey) links.next else firstKey
         val newLastKey = if (key == lastKey) links.previous else lastKey

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

@@ -67,22 +67,22 @@ internal class PersistentOrderedMapBuilder<K, V>(private var map: PersistentOrde
             if (links.value == value) {
                 return value
             }
-            mapBuilder[key] = Links(value, links.previous, links.next)
+            mapBuilder[key] = LinkedValue(value, links.previous, links.next)
             return links.value
         }
 
         if (isEmpty()) {  //  isEmpty
             firstKey = key
             lastKey = key
-            mapBuilder[key] = Links<K, V>(value, null, null)
+            mapBuilder[key] = LinkedValue<K, V>(value, null, null)
             return null
         }
         val oldLinks = mapBuilder[lastKey]!!
         assert(oldLinks.next == null)
-        val newLinks = Links(oldLinks.value, oldLinks.previous, key)
+        val newLinks = LinkedValue(oldLinks.value, oldLinks.previous, key)
 
         mapBuilder[lastKey as K] = newLinks
-        mapBuilder[key] = Links(value, lastKey, null)
+        mapBuilder[key] = LinkedValue(value, lastKey, null)
         lastKey = key
         return null
     }
@@ -93,12 +93,12 @@ internal class PersistentOrderedMapBuilder<K, V>(private var map: PersistentOrde
         if (links.previous != null) {
             val previousLinks = mapBuilder[links.previous]!!
             assert(previousLinks.next == key)
-            mapBuilder[links.previous] = Links(previousLinks.value, previousLinks.previous, links.next)
+            mapBuilder[links.previous] = LinkedValue(previousLinks.value, previousLinks.previous, links.next)
         }
         if (links.next != null) {
             val nextLinks = mapBuilder[links.next]!!
             assert(nextLinks.previous == key)
-            mapBuilder[links.next] = Links(nextLinks.value, links.previous, nextLinks.next)
+            mapBuilder[links.next] = LinkedValue(nextLinks.value, links.previous, nextLinks.next)
         }
         firstKey = if (key == firstKey) links.next else firstKey
         lastKey = if (key == lastKey) links.previous else lastKey

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

@@ -19,7 +19,7 @@ package kotlinx.collections.immutable.implementations.persistentOrderedMap
 import kotlinx.collections.immutable.implementations.immutableMap.MapEntry
 
 internal open class PersistentOrderedMapBuilderLinksIterator<K, V>(internal var nextKey: K?,
-                                                                   internal val map: MutableMap<K, Links<K, V>>) : MutableIterator<Links<K, V>> {
+                                                                   internal val map: MutableMap<K, LinkedValue<K, V>>) : MutableIterator<LinkedValue<K, V>> {
     internal var lastProcessedKey: K? = null
     private var nextWasInvoked = false
     internal var index = 0
@@ -28,7 +28,7 @@ internal open class PersistentOrderedMapBuilderLinksIterator<K, V>(internal var
         return index < map.size
     }
 
-    override fun next(): Links<K, V> {
+    override fun next(): LinkedValue<K, V> {
         if (!hasNext()) {
             throw NoSuchElementException()
         }
@@ -68,15 +68,15 @@ internal class PersistentOrderedMapBuilderEntriesIterator<K, V>(map: PersistentO
     }
 }
 
-private class MutableMapEntry<K, V>(private val mutableMap: MutableMap<K, Links<K, V>>,
+private class MutableMapEntry<K, V>(private val mutableMap: MutableMap<K, LinkedValue<K, V>>,
                                     key: K,
-                                    private var links: Links<K, V>) : MapEntry<K, V>(key, links.value), MutableMap.MutableEntry<K, V> {
+                                    private var links: LinkedValue<K, V>) : MapEntry<K, V>(key, links.value), MutableMap.MutableEntry<K, V> {
     override val value: V
         get() = links.value
 
     override fun setValue(newValue: V): V {
         val result = links.value
-        links = Links(newValue, links.previous, links.next)
+        links = LinkedValue(newValue, links.previous, links.next)
         mutableMap[key] = links
         return result
     }

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

@@ -19,14 +19,14 @@ package kotlinx.collections.immutable.implementations.persistentOrderedMap
 import kotlinx.collections.immutable.implementations.immutableMap.MapEntry
 
 internal open class PersistentOrderedMapLinksIterator<K, out V>(internal var nextKey: K?,
-                                                                internal val map: Map<K, Links<K, V>>) : Iterator<Links<K, V>> {
+                                                                internal val map: Map<K, LinkedValue<K, V>>) : Iterator<LinkedValue<K, V>> {
     internal var index = 0
 
     override fun hasNext(): Boolean {
         return index < map.size
     }
 
-    override fun next(): Links<K, V> {
+    override fun next(): LinkedValue<K, V> {
         if (!hasNext()) {
             throw NoSuchElementException()
         }