org.fernice.reflare.util.ObservableCollection.kt Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of fernice-reflare Show documentation
CSS integration through fernice-flare in Java Swing as a LookAndFeel
The newest version!
/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */

package org.fernice.reflare.util

internal fun  observableMutableSetOf(vararg elements: E): ObservableMutableSet {
    return ObservableMutableSetWrapper(mutableSetOf(*elements))
}

internal inline fun  observableMutableSetOf(elements: Collection, noinline listener: () -> Unit): ObservableMutableSet {
    val list = observableMutableSetOf(*elements.toTypedArray())
    list.addInvalidationListener(listener)
    return list
}

internal fun  observableMutableSetOf(listener: () -> Unit): ObservableMutableSet {
    val list = observableMutableSetOf()
    list.addInvalidationListener(listener)
    return list
}

internal interface ObservableCollection {

    fun addInvalidationListener(listener: () -> Unit)
    fun removeInvalidationListener(listener: () -> Unit)
}

internal interface ObservableMutableSet : MutableSet, ObservableCollection

private abstract class ObservableCollectionWrapperBase>(protected val delegate: S) : Collection, ObservableCollection {

    protected fun mutableIterator(): Iterator = MutableIteratorWrapper(iterator() as MutableIterator)

    protected inline fun  withInvalidation(block: () -> R): R {
        val result = block()
        invalidated()
        return result
    }

    protected inline fun withConditionalInvalidation(block: () -> Boolean): Boolean {
        val result = block()
        if (result) {
            invalidated()
        }
        return result
    }

    private fun invalidated() {
        listeners.forEach { it() }
    }

    private val listeners = mutableListOf<() -> Unit>()

    override fun addInvalidationListener(listener: () -> Unit) {
        listeners.add(listener)
    }

    override fun removeInvalidationListener(listener: () -> Unit) {
        listeners.remove(listener)
    }

    private inner class MutableIteratorWrapper(private val iterator: MutableIterator) : MutableIterator {

        override fun hasNext(): Boolean = iterator.hasNext()
        override fun next(): E = iterator.next()

        override fun remove() = withInvalidation { iterator.remove() }
    }
}

private open class ObservableSetWrapper>(delegate: S) : ObservableCollectionWrapperBase(delegate), Set {

    override val size: Int
        get() = delegate.size

    override fun contains(element: E): Boolean = delegate.contains(element)
    override fun containsAll(elements: Collection): Boolean = delegate.containsAll(elements)
    override fun isEmpty(): Boolean = delegate.isEmpty()
    override fun iterator(): Iterator = delegate.iterator()
}

private class ObservableMutableSetWrapper(delegate: MutableSet) : ObservableSetWrapper>(delegate), MutableSet,
    ObservableMutableSet {

    override fun add(element: E): Boolean = withConditionalInvalidation { delegate.add(element) }
    override fun addAll(elements: Collection): Boolean = withConditionalInvalidation { delegate.addAll(elements) }

    override fun remove(element: E): Boolean = withConditionalInvalidation { delegate.remove(element) }
    override fun removeAll(elements: Collection): Boolean = withConditionalInvalidation { delegate.removeAll(elements) }

    override fun retainAll(elements: Collection): Boolean = withConditionalInvalidation { delegate.retainAll(elements) }

    override fun clear() = withInvalidation { delegate.clear() }

    override fun iterator(): MutableIterator = delegate.iterator()
}