name.remal.collections.kt Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of common Show documentation
Java & Kotlin tools: common
There is a newer version: 1.26.147
package name.remal

import name.remal.collections.ObservableList
import name.remal.collections.ObservableMap
import name.remal.collections.ObservableSet
import java.util.*
import java.util.Collections.newSetFromMap
import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.ConcurrentMap
import java.util.concurrent.CopyOnWriteArrayList

fun  queueOf(): Queue = LinkedList()
fun  queueOf(vararg elements: T): Queue = LinkedList().apply { addAll(elements) }

fun  dequeOf(): Deque = LinkedList()
fun  dequeOf(vararg elements: T): Deque = LinkedList().apply { addAll(elements) }

fun  concurrentSetOf(): MutableSet = newSetFromMap(ConcurrentHashMap())
fun  concurrentSetOf(vararg elements: T): MutableSet = newSetFromMap(ConcurrentHashMap()).apply { addAll(elements) }

fun  synchronizedSetOf(): MutableSet = mutableSetOf().asSynchronized()
fun  synchronizedSetOf(vararg elements: T): MutableSet = mutableSetOf(*elements).asSynchronized()

fun  synchronizedSortedSetOf(): SortedSet = sortedSetOf().asSynchronized()
fun  synchronizedSortedSetOf(vararg elements: T): SortedSet = sortedSetOf(*elements).asSynchronized()

fun  synchronizedNavigableSetOf(): NavigableSet = sortedSetOf().asSynchronized()
fun  synchronizedNavigableSetOf(vararg elements: T): NavigableSet = sortedSetOf(*elements).asSynchronized()

fun  synchronizedListOf(): MutableList = mutableListOf().asSynchronized()
fun  synchronizedListOf(vararg elements: T): MutableList = mutableListOf(*elements).asSynchronized()

fun  copyOnWriteListOf() = CopyOnWriteArrayList()
fun  copyOnWriteListOf(vararg elements: T) = CopyOnWriteArrayList().apply { addAll(elements) }


fun , V> navigableMapOf(): NavigableMap = TreeMap()
fun , V> navigableMapOf(vararg pairs: Pair): NavigableMap = TreeMap().apply { putAll(pairs) }

fun  concurrentMapOf(): ConcurrentMap = ConcurrentHashMap()
fun  concurrentMapOf(vararg pairs: Pair): ConcurrentMap = ConcurrentHashMap().apply { putAll(pairs) }

fun  synchronizedMapOf(): MutableMap = mutableMapOf().asSynchronized()
fun  synchronizedMapOf(vararg pairs: Pair): MutableMap = mutableMapOf(*pairs).asSynchronized()

fun , V> synchronizedSortedMapOf(): SortedMap = sortedMapOf().asSynchronized()
fun , V> synchronizedSortedMapOf(vararg pairs: Pair): SortedMap = sortedMapOf(*pairs).asSynchronized()

fun , V> synchronizedNavigableMapOf(): NavigableMap = navigableMapOf().asSynchronized()
fun , V> synchronizedNavigableMapOf(vararg pairs: Pair): NavigableMap = navigableMapOf(*pairs).asSynchronized()

fun  observableListOf(vararg elements: T): ObservableList = mutableListOf(*elements).asObservable()
fun  observableSetOf(vararg elements: T): ObservableSet = mutableSetOf(*elements).asObservable()
fun  observableMapOf(vararg pairs: Pair): ObservableMap = mutableMapOf(*pairs).asObservable()


inline fun  buildList(builderAction: ListBuilder.() -> Unit): List {
    val list = mutableListOf()
    builderAction(object : ListBuilder {
        override fun isEmpty() = list.isEmpty()
        override fun contains(element: T) = list.contains(element)
        override fun add(element: T) = list.add(element)
        override fun clear() = list.clear()
    })
    return list
}

interface ListBuilder {
    fun isEmpty(): Boolean
    fun isNotEmpty(): Boolean = !isEmpty()
    operator fun contains(element: T): Boolean
    fun containsAll(elements: Iterable) = elements.all { contains(it) }
    fun add(element: T): Boolean
    fun addAll(elements: Iterable) = 1 <= elements.count { add(it) }
    fun addAll(vararg elements: T) = 1 <= elements.count { add(it) }
    fun clear()
}


inline fun  buildSet(builderAction: SetBuilder.() -> Unit): Set {
    val set = mutableSetOf()
    builderAction(object : SetBuilder {
        override fun isEmpty() = set.isEmpty()
        override fun contains(element: T) = set.contains(element)
        override fun add(element: T) = set.add(element)
        override fun remove(element: T) = set.remove(element)
        override fun clear() = set.clear()
    })
    return set
}

interface SetBuilder {
    fun isEmpty(): Boolean
    fun isNotEmpty(): Boolean = !isEmpty()
    operator fun contains(element: T): Boolean
    fun containsAll(elements: Iterable) = elements.all { contains(it) }
    fun add(element: T): Boolean
    fun addAll(elements: Iterable) = 1 <= elements.count { add(it) }
    fun addAll(vararg elements: T) = 1 <= elements.count { add(it) }
    fun remove(element: T): Boolean
    fun removeAll(elements: Iterable) = 1 <= elements.count { remove(it) }
    fun clear()
}


inline fun  buildMap(builderAction: MapBuilder.() -> Unit): Map {
    val map = mutableMapOf()
    builderAction(object : MapBuilder {
        override fun isEmpty() = map.isEmpty()
        override fun containsKey(key: K) = map.containsKey(key)
        override fun containsValue(value: V) = map.containsValue(value)
        override fun put(key: K, value: V) = map.put(key, value)
        override fun remove(key: K): V? = map.remove(key)
        override fun clear() = map.clear()
    })
    return map
}

interface MapBuilder {
    fun isEmpty(): Boolean
    fun isNotEmpty(): Boolean = !isEmpty()
    fun containsKey(key: K): Boolean
    fun containsValue(value: V): Boolean
    fun put(key: K, value: V): V?
    fun putAll(from: Map) = from.forEach { key, value -> put(key, value) }
    fun remove(key: K): V?
    fun removeAll(keys: Iterable) = keys.forEach { remove(it) }
    fun clear()
    operator fun contains(key: K) = containsKey(key)
    operator fun set(key: K, value: V) = put(key, value)
}