forEach

class Bindable<T>() {
    private val bindings: WeakReferenceList<Bindable<T>> = mutableWeakListOf()

    fun unbindFrom(bindable: Bindable<T>) {
        removeBinding(bindable.weakReference)
        bindable.removeBinding(weakReference)
    }

    private fun removeBinding(ref: WeakReference<Bindable<T>>) {
        bindings.remove(ref)
    }

    fun unbindBindings() {
        if (bindings.isNotEmpty()) {
            bindings.forAliveRefs { it.unbindFrom(this) }
            bindings.clear()
        }
    }
}

internal class WeakReferenceList<T>(private val delegate: MutableList<WeakReference<T>>) :
    MutableList<WeakReference<T>> by delegate {

    override fun contains(element: WeakReference<T>): Boolean = synchronized(this) {
        return delegate.any { it.get()?.equals(element) ?: false }
    }

    fun forAliveRefs(clearDestroyedRefs: Boolean = true, action: (T) -> Unit) = synchronized(this) {
        if (clearDestroyedRefs) removeDestroyedRefs()

        delegate.forEach { it.get()?.let(action) }
    }
}

ConcurrentModificationException

forEach

iterator

fun getAliveRefs(): List<WeakReference<T>> = synchronized(this) {
    delegate.filter { it.get() != null }
}

fun forAliveRefs(action: (T) -> Unit) = synchronized(this) {
    getAliveRefs().forEach { it.get()?.let(action) }
}