Implement PersistentHashSet

Author: Abduqodiri Qurbonzoda

kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableSet/PersistentHashSet.kt

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+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>,
+                                    override val size: Int): AbstractSet<E>(), PersistentSet<E> {
+    override fun contains(element: E): Boolean {
+        val hashCode = element?.hashCode() ?: NULL_HASH_CODE
+        return node.contains(hashCode, element, 0)
+    }
+
+    override fun add(element: E): PersistentSet<E> {
+        val hashCode = element?.hashCode() ?: NULL_HASH_CODE
+        val newNode = node.add(hashCode, element, 0)
+        if (node === newNode) { return this }
+        return PersistentHashSet(newNode, size + 1)
+    }
+
+    override fun addAll(elements: Collection<E>): PersistentSet<E> {
+        return this.mutate { it.addAll(elements) }
+    }
+
+    override fun remove(element: E): PersistentSet<E> {
+        val hashCode = element?.hashCode() ?: NULL_HASH_CODE
+        val newNode = node.remove(hashCode, element, 0)
+        if (node === newNode) { return this }
+        if (newNode == null) { return persistentHashSetOf() }
+        return PersistentHashSet(newNode, size - 1)
+    }
+
+    override fun removeAll(elements: Collection<E>): PersistentSet<E> {
+        return mutate { it.removeAll(elements) }
+    }
+
+    override fun removeAll(predicate: (E) -> Boolean): PersistentSet<E> {
+        return mutate { it.removeAll(predicate) }
+    }
+
+    override fun clear(): PersistentSet<E> {
+        return persistentHashSetOf()
+    }
+
+    override fun iterator(): Iterator<E> {
+        return PersistentHashSetIterator(node)
+    }
+
+    override fun builder(): PersistentSet.Builder<E> {
+        return PersistentHashSetBuilder(node, size)
+    }
+
+    internal companion object {
+        internal val EMPTY = PersistentHashSet(TrieNode.EMPTY, 0)
+    }
+}
+
+fun <E> persistentHashSetOf(): PersistentSet<E> {
+    return PersistentHashSet.EMPTY
+}

kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableSet/PersistentHashSetBuilder.kt

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package kotlinx.collections.immutable.implementations.immutableSet
+
+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 var marker = Marker()
+
+    override fun build(): PersistentSet<E> {
+        marker = Marker()
+        return PersistentHashSet(node, size)
+    }
+
+    override fun contains(element: E): Boolean {
+        val hashCode = element?.hashCode() ?: NULL_HASH_CODE
+        return node.contains(hashCode, element, 0)
+    }
+
+    override fun add(element: E): Boolean {
+        val hashCode = element?.hashCode() ?: NULL_HASH_CODE
+        node = node.makeMutableFor(this)
+        return node.mutableAdd(hashCode, element, 0, this)
+    }
+
+    override fun remove(element: E): Boolean {
+        val hashCode = element?.hashCode() ?: NULL_HASH_CODE
+        node = node.makeMutableFor(this)
+        return node.mutableRemove(hashCode, element, 0, this)
+    }
+
+    override fun clear() {
+        node = TrieNode.EMPTY as TrieNode<E>
+        size = 0
+    }
+
+    override fun iterator(): MutableIterator<E> {
+        return PersistentHashSetMutableIterator(this)
+    }
+}

kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableSet/PersistentHashSetIterator.kt

@@ -0,0 +1,126 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package kotlinx.collections.immutable.implementations.immutableSet
+
+internal open class PersistentHashSetIterator<E>(node: TrieNode<E>) : Iterator<E> {
+    protected val path = mutableListOf(TrieNodeIterator<E>())
+    protected var pathLastIndex = 0
+    private var hasNext = true
+
+    init {
+        path[0].reset(node.buffer)
+        pathLastIndex = 0
+        ensureNextElementIsReady()
+    }
+
+    private fun moveToNextNodeWithData(pathIndex: Int): Int {
+        if (path[pathIndex].hasNextElement()) {
+            return pathIndex
+        }
+        if (path[pathIndex].hasNextNode()) {
+            val node = path[pathIndex].currentNode()
+
+            if (pathIndex + 1 == path.size) {
+                path.add(TrieNodeIterator())
+            }
+            path[pathIndex + 1].reset(node.buffer)
+            return moveToNextNodeWithData(pathIndex + 1)
+        }
+        return -1
+    }
+
+    private fun ensureNextElementIsReady() {
+        if (path[pathLastIndex].hasNextElement()) {
+            return
+        }
+        for(i in pathLastIndex downTo 0) {
+            var result = moveToNextNodeWithData(i)
+
+            if (result == -1 && path[i].hasNextCell()) {
+                path[i].moveToNextCell()
+                result = moveToNextNodeWithData(i)
+            }
+            if (result != -1) {
+                pathLastIndex = result
+                return
+            }
+            if (i > 0) {
+                path[i - 1].moveToNextCell()
+            }
+        }
+        hasNext = false
+    }
+
+    override fun hasNext(): Boolean {
+        return hasNext
+    }
+
+    override fun next(): E {
+        assert(hasNext())
+
+        val result = path[pathLastIndex].nextElement()
+        ensureNextElementIsReady()
+        return result
+    }
+
+    protected fun currentElement(): E {
+        assert(hasNext())
+        return path[pathLastIndex].currentElement()
+    }
+}
+
+internal class TrieNodeIterator<out E> {
+    private var buffer = emptyArray<Any?>()
+    private var index = 0
+
+    fun reset(buffer: Array<Any?>, index: Int = 0) {
+        this.buffer = buffer
+        this.index = index
+    }
+
+    fun hasNextCell(): Boolean {
+        return index < buffer.size
+    }
+
+    fun moveToNextCell() {
+        assert(hasNextCell())
+        index++
+    }
+
+    fun hasNextElement(): Boolean {
+        return hasNextCell() && buffer[index] !is TrieNode<*>
+    }
+
+    fun currentElement(): E {
+        assert(hasNextElement())
+        return buffer[index] as E
+    }
+
+    fun nextElement(): E {
+        assert(hasNextElement())
+        return buffer[index++] as E
+    }
+
+    fun hasNextNode(): Boolean {
+        return hasNextCell() && buffer[index] is TrieNode<*>
+    }
+
+    fun currentNode(): TrieNode<out E> {
+        assert(hasNextNode())
+        return buffer[index] as TrieNode<E>
+    }
+}

kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableSet/PersistentHashSetMutableIterator.kt

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package kotlinx.collections.immutable.implementations.immutableSet
+
+internal class PersistentHashSetMutableIterator<E>(private val builder: PersistentHashSetBuilder<E>)
+    : PersistentHashSetIterator<E>(builder.node), MutableIterator<E> {
+    var lastReturned: E? = null
+    var nextWasInvoked = false
+
+    override fun next(): E {
+        val next = super.next()
+        lastReturned = next
+        nextWasInvoked = true
+        return next
+    }
+
+    override fun remove() {
+        if (!nextWasInvoked) {
+            throw NoSuchElementException()
+        }
+        if (hasNext()) {
+            val currentElement = currentElement()
+
+            assert(builder.remove(lastReturned))
+            resetPath(currentElement?.hashCode() ?: NULL_HASH_CODE, builder.node, currentElement, 0)
+        } else {
+            assert(builder.remove(lastReturned))
+        }
+
+        lastReturned = null
+        nextWasInvoked = false
+    }
+
+    private fun resetPath(hashCode: Int, node: TrieNode<*>, element: E, pathIndex: Int) {
+        if (isCollision(node)) {
+            val index = node.buffer.indexOf(element)
+            assert(index != -1)
+            path[pathIndex].reset(node.buffer, index)
+            pathLastIndex = pathIndex
+            return
+        }
+
+        val position = 1 shl ((hashCode shr (pathIndex * LOG_MAX_BRANCHING_FACTOR)) and MAX_BRANCHING_FACTOR_MINUS_ONE)
+        val index = Integer.bitCount(node.bitmap and (position - 1))
+
+        path[pathIndex].reset(node.buffer, index)
+
+        val cell = node.buffer[index]
+        if (cell is TrieNode<*>) {
+            resetPath(hashCode, cell, element, pathIndex + 1)
+        } else {
+            assert(cell == element)
+            pathLastIndex = pathIndex
+        }
+    }
+
+    private fun isCollision(node: TrieNode<*>): Boolean {
+        return node.bitmap == 0
+    }
+}