com.lightningkite.lightningdb.ModificationBuilder.kt Maven / Gradle / Ivy

Go to download
@file:SharedCode
package com.lightningkite.lightningdb

import com.lightningkite.khrysalis.IsCodableAndHashable
import com.lightningkite.khrysalis.JsName
import com.lightningkite.khrysalis.SharedCode

inline fun  modification(setup: ModificationBuilder.(DataClassPath) -> Unit): Modification {
    return ModificationBuilder().apply {
        setup(this, path())
    }.build()
}

inline fun  Modification.and(setup: ModificationBuilder.(DataClassPath) -> Unit): Modification {
    return ModificationBuilder().apply {
        this.modifications.add(this@and)
        setup(this, path())
    }.build()
}

class ModificationBuilder() {
    val modifications = ArrayList>()
    fun add(modification: Modification) { modifications.add(modification) }
    fun build(): Modification {
        if(modifications.size == 1) return modifications[0]
        else return Modification.Chain(modifications)
    }

    @JsName("assign")
    infix fun  DataClassPath.assign(value: T) {
        modifications.add(mapModification(Modification.Assign(value)))
    }

    @JsName("coerceAtMost")
    infix fun > DataClassPath.coerceAtMost(value: T) {
        modifications.add(mapModification(Modification.CoerceAtMost(value)))
    }

    @JsName("coerceAtLeast")
    infix fun > DataClassPath.coerceAtLeast(value: T) {
        modifications.add(mapModification(Modification.CoerceAtLeast(value)))
    }

    @JsName("plusAssignNumber")
    infix operator fun  DataClassPath.plusAssign(by: T) {
        modifications.add(mapModification(Modification.Increment(by)))
    }

    @JsName("timesAssign")
    infix operator fun  DataClassPath.timesAssign(by: T) {
        modifications.add(mapModification(Modification.Multiply(by)))
    }

    @JsName("plusAssignString")
    infix operator fun DataClassPath.plusAssign(value: String) {
        modifications.add(mapModification(Modification.AppendString(value)))
    }

    @JsName("plusAssignList")
    infix operator fun  DataClassPath>.plusAssign(items: List) {
        modifications.add(mapModification(Modification.ListAppend(items)))
    }

    @JsName("plusAssignSet")
    infix operator fun  DataClassPath>.plusAssign(items: Set) {
        modifications.add(mapModification(Modification.SetAppend(items)))
    }

    @JsName("plusAssignItemList")
    @JvmName("plusList")
    infix operator fun  DataClassPath>.plusAssign(item: T) {
        modifications.add(mapModification(Modification.ListAppend(listOf(item))))
    }

    @JsName("plusAssignItemSet")
    @JvmName("plusSet")
    infix operator fun  DataClassPath>.plusAssign(item: T) {
        modifications.add(mapModification(Modification.SetAppend(setOf(item))))
    }

    @JsName("plusAssignListAddAll")
    infix fun  DataClassPath>.addAll(items: List) {
        modifications.add(mapModification(Modification.ListAppend(items)))
    }

    @JsName("plusAssignSetAddAll")
    infix fun  DataClassPath>.addAll(items: Set) {
        modifications.add(mapModification(Modification.SetAppend(items)))
    }

    @JsName("removeAllList")
    @JvmName("removeAllList")
    infix fun  DataClassPath>.removeAll(condition: (DataClassPath) -> Condition) {
        modifications.add(mapModification(Modification.ListRemove(path().let(condition))))
    }

    @JsName("removeAllSet")
    @JvmName("removeAllSet")
    infix fun  DataClassPath>.removeAll(condition: (DataClassPath) -> Condition) {
        modifications.add(mapModification(Modification.SetRemove(path().let(condition))))
    }

    @JsName("removeAllItemsList")
    infix fun  DataClassPath>.removeAll(items: List) {
        modifications.add(mapModification(Modification.ListRemoveInstances(items)))
    }

    @JsName("removeAllItemsSet")
    infix fun  DataClassPath>.removeAll(items: Set) {
        modifications.add(mapModification(Modification.SetRemoveInstances(items)))
    }

    @JsName("dropLastList")
    @JvmName("dropLastList")
    fun  DataClassPath>.dropLast() {
        modifications.add(mapModification(Modification.ListDropLast()))
    }

    @JsName("dropLastSet")
    @JvmName("dropLastSet")
    fun  DataClassPath>.dropLast() {
        modifications.add(mapModification(Modification.SetDropLast()))
    }

    @JsName("dropFirstList")
    @JvmName("dropFirstList")
    fun  DataClassPath>.dropFirst() {
        modifications.add(mapModification(Modification.ListDropFirst()))
    }

    @JsName("dropFirstSet")
    @JvmName("dropFirstSet")
    fun  DataClassPath>.dropFirst() {
        modifications.add(mapModification(Modification.SetDropFirst()))
    }

    @JsName("forEachList")
    @JvmName("forEachList")
    inline infix fun  DataClassPath>.forEach(modification: ModificationBuilder.(DataClassPath) -> Unit) {
        val builder = ModificationBuilder()
        modification(builder, path())
        modifications.add(
            mapModification(
                Modification.ListPerElement(
                    condition = Condition.Always(),
                    modification = builder.build()
                )
            )
        )
    }

    @JsName("forEachSet")
    @JvmName("forEachSet")
    inline infix fun  DataClassPath>.forEach(modification: ModificationBuilder.(DataClassPath) -> Unit) {
        val builder = ModificationBuilder()
        modification(builder, path())
        modifications.add(
            mapModification(
                Modification.SetPerElement(
                    condition = Condition.Always(),
                    modification = builder.build()
                )
            )
        )
    }

    @JsName("forEachIfList")
    @JvmName("forEachIfList")
    inline fun  DataClassPath>.forEachIf(
        condition: (DataClassPath) -> Condition,
        modification: ModificationBuilder.(DataClassPath) -> Unit,
    ) {
        val builder = ModificationBuilder()
        modification(builder, path())
        modifications.add(
            mapModification(
                Modification.ListPerElement(
                    condition = path().let(condition),
                    modification = builder.build()
                )
            )
        )
    }

    @JsName("forEachIfSet")
    @JvmName("forEachIfSet")
    inline fun  DataClassPath>.forEachIf(
        condition: (DataClassPath) -> Condition,
        modification: ModificationBuilder.(DataClassPath) -> Unit,
    ) {
        val builder = ModificationBuilder()
        modification(builder, path())
        modifications.add(
            mapModification(
                Modification.SetPerElement(
                    condition = path().let(condition),
                    modification = builder.build()
                )
            )
        )
    }

    @JsName("plusAssignMap")
    infix operator fun  DataClassPath>.plusAssign(map: Map) {
        modifications.add(mapModification(Modification.Combine(map)))
    }

    @JsName("modifyByKey")
    infix fun  DataClassPath>.modifyByKey(byKey: Map.(DataClassPath) -> Unit>) {
        modifications.add(mapModification(Modification.ModifyByKey(byKey.mapValues { modification(it.value) })))
    }

    @JsName("removeKeys")
    infix fun  DataClassPath>.removeKeys(fields: Set) {
        modifications.add(mapModification(Modification.RemoveKeys(fields)))
    }
}