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

Go to download
Show more of this group Show more artifacts with this name
Show all versions of common Show documentation
Java & Kotlin tools: common
The newest version!
package name.remal

import name.remal.collections.ObservableList
import name.remal.collections.ObservableMap
import name.remal.collections.ObservableSet
import java.util.Collections.newSetFromMap
import java.util.Deque
import java.util.LinkedList
import java.util.NavigableMap
import java.util.NavigableSet
import java.util.Queue
import java.util.SortedMap
import java.util.SortedSet
import java.util.TreeMap
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)
}