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

Go to download
@file:OptIn(ExperimentalSerializationApi::class, InternalSerializationApi::class)

package com.lightningkite.lightningdb

import com.lightningkite.khrysalis.IsEquatable
import com.lightningkite.khrysalis.fatalError
import kotlinx.serialization.*
import kotlin.reflect.KClass
import kotlinx.serialization.builtins.ListSerializer
import kotlinx.serialization.builtins.SetSerializer
import kotlinx.serialization.builtins.serializer
import kotlinx.serialization.descriptors.*
import kotlinx.serialization.encoding.Decoder
import kotlinx.serialization.encoding.Encoder
import kotlinx.serialization.internal.GeneratedSerializer
import java.lang.IllegalStateException
import java.util.*
import kotlin.reflect.KProperty1
import kotlin.reflect.full.allSupertypes
import kotlin.reflect.jvm.jvmErasure

fun  KSerializer.fieldSerializer(property: KProperty1): KSerializer? {
    val index = this.descriptor.elementNames.indexOf(property.name)
    @Suppress("UNCHECKED_CAST")
    return (this as? GeneratedSerializer<*>)?.childSerializers()?.get(index) as? KSerializer
}

fun  KSerializer.fieldSerializer(fieldName: String): KSerializer<*>? {
    val index = this.descriptor.elementNames.indexOf(fieldName)
    return (this as? GeneratedSerializer<*>)?.childSerializers()?.get(index)
}

private val serializers = HashMap, MySealedClassSerializerInterface<*>>()

@Suppress("UNCHECKED_CAST")
private fun  getCond(inner: KSerializer): MySealedClassSerializerInterface> = serializers.getOrPut(inner) {
    MySealedClassSerializer(
        "com.lightningkite.lightningdb.Condition",
        Condition::class as KClass>,
        {
            val map = LinkedHashMap>>()
            fun register(serializer: KSerializer>) {
                map[serializer.descriptor.serialName] = (serializer as KSerializer>)
            }
            register(Condition.Never.serializer(inner))
            register(Condition.Always.serializer(inner))
            register(Condition.And.serializer(inner))
            register(Condition.Or.serializer(inner))
            register(Condition.Not.serializer(inner))
            register(Condition.Equal.serializer(inner))
            register(Condition.NotEqual.serializer(inner))
            register(Condition.Inside.serializer(inner))
            register(Condition.NotInside.serializer(inner))

//            if(inner.descriptor.kind is PrimitiveKind) {
                register(Condition.GreaterThan.serializer(inner))
                register(Condition.LessThan.serializer(inner))
                register(Condition.GreaterThanOrEqual.serializer(inner))
                register(Condition.LessThanOrEqual.serializer(inner))
//            }

            register(Condition.FullTextSearch.serializer(inner))
            if (inner == String.serializer()) {
                register(Condition.StringContains.serializer())
                register(Condition.RegexMatches.serializer())
            }
            if (inner == Int.serializer()) {
                register(Condition.IntBitsClear.serializer())
                register(Condition.IntBitsSet.serializer())
                register(Condition.IntBitsAnyClear.serializer())
                register(Condition.IntBitsAnySet.serializer())
            }
            if (inner.descriptor.kind == StructureKind.LIST) {
                inner.listElement()?.let { element ->
                    register(Condition.ListAllElements.serializer(element))
                    register(Condition.ListAnyElements.serializer(element))
                    register(Condition.ListSizesEquals.serializer(element))
                    register(Condition.SetAllElements.serializer(element))
                    register(Condition.SetAnyElements.serializer(element))
                    register(Condition.SetSizesEquals.serializer(element))
                }
            }
            if (inner.descriptor.kind == StructureKind.MAP) {
                inner.mapValueElement()?.let { element ->
                    register(Condition.Exists.serializer(element))
                    register(Condition.OnKey.serializer(element))
                }
            }
            if (inner is GeneratedSerializer<*> && inner.descriptor.kind == StructureKind.CLASS && inner !is MySealedClassSerializerInterface) {
                val childSerializers = inner.childSerializers()
                val fields = try {inner.attemptGrabFields() } catch(e: Exception) { throw Exception("Failed while getting inner fields from ${inner}", e)}
                for (index in 0 until inner.descriptor.elementsCount) {
                    val name = inner.descriptor.getElementName(index)
                    val prop = fields[name]!!
                    register(
                        OnFieldSerializer(
                            prop as KProperty1,
                            Condition.serializer(childSerializers[index]) as KSerializer>
                        )
                    )
                }
            }
            if (inner.descriptor.isNullable) {
                inner.nullElement()?.let { element ->
                    register(Condition.IfNotNull.serializer(element))
                }
            }
            map
        },
        alternateReadNames = mapOf(
            "Search" to "StringContains",
            "AllElements" to "ListAllElements",
            "AnyElements" to "ListAnyElements",
            "SizesEquals" to "ListSizesEquals",
        ),
        annotations = Condition::class.annotations
    ) {
        when (it) {
            is Condition.Never -> "Never"
            is Condition.Always -> "Always"
            is Condition.And -> "And"
            is Condition.Or -> "Or"
            is Condition.Not -> "Not"
            is Condition.Equal -> "Equal"
            is Condition.NotEqual -> "NotEqual"
            is Condition.Inside -> "Inside"
            is Condition.NotInside -> "NotInside"
            is Condition.GreaterThan -> "GreaterThan"
            is Condition.LessThan -> "LessThan"
            is Condition.GreaterThanOrEqual -> "GreaterThanOrEqual"
            is Condition.LessThanOrEqual -> "LessThanOrEqual"
            is Condition.StringContains -> "StringContains"
            is Condition.RegexMatches -> "RegexMatches"
            is Condition.FullTextSearch -> "FullTextSearch"
            is Condition.IntBitsClear -> "IntBitsClear"
            is Condition.IntBitsSet -> "IntBitsSet"
            is Condition.IntBitsAnyClear -> "IntBitsAnyClear"
            is Condition.IntBitsAnySet -> "IntBitsAnySet"
            is Condition.ListAllElements<*> -> "ListAllElements"
            is Condition.ListAnyElements<*> -> "ListAnyElements"
            is Condition.ListSizesEquals<*> -> "ListSizesEquals"
            is Condition.SetAllElements<*> -> "SetAllElements"
            is Condition.SetAnyElements<*> -> "SetAnyElements"
            is Condition.SetSizesEquals<*> -> "SetSizesEquals"
            is Condition.Exists<*> -> "Exists"
            is Condition.OnKey<*> -> "OnKey"
            is Condition.IfNotNull<*> -> "IfNotNull"
            is Condition.OnField<*, *> -> it.key.name
            else -> fatalError()
        }
    }
} as MySealedClassSerializerInterface>

class ConditionSerializer(val inner: KSerializer) : MySealedClassSerializerInterface> by getCond(inner)

class OnFieldSerializer(
    val field: KProperty1,
    val conditionSerializer: KSerializer>
) : WrappingSerializer, Condition>(field.name) {
    override fun getDeferred(): KSerializer> = conditionSerializer
    override fun inner(it: Condition.OnField): Condition = it.condition
    override fun outer(it: Condition): Condition.OnField = Condition.OnField(field, it)
}

class LazyRenamedSerialDescriptor(override val serialName: String, val getter: () -> SerialDescriptor) :
    SerialDescriptor {
    override val elementsCount: Int get() = getter().elementsCount
    override val kind: SerialKind get() = getter().kind
    override fun getElementAnnotations(index: Int): List = getter().getElementAnnotations(index)
    override fun getElementDescriptor(index: Int): SerialDescriptor = getter().getElementDescriptor(index)
    override fun getElementIndex(name: String): Int = getter().getElementIndex(name)
    override fun getElementName(index: Int): String = getter().getElementName(index)
    override fun isElementOptional(index: Int): Boolean = getter().isElementOptional(index)
}


class ConditionNeverSerializer(val inner: KSerializer) : WrappingSerializer, Boolean>("Never") {
    override fun getDeferred(): KSerializer = Boolean.serializer()
    override fun inner(it: Condition.Never): Boolean = true
    override fun outer(it: Boolean) = Condition.Never()
}

class ConditionAlwaysSerializer(val inner: KSerializer) : WrappingSerializer, Boolean>("Always") {
    override fun getDeferred(): KSerializer = Boolean.serializer()
    override fun inner(it: Condition.Always): Boolean = true
    override fun outer(it: Boolean) = Condition.Always()
}

class ConditionAndSerializer(val inner: KSerializer): WrappingSerializer, List>>("And") {
    override fun getDeferred(): KSerializer>> = ListSerializer(Condition.serializer(inner))
    override fun inner(it: Condition.And): List> = it.conditions
    override fun outer(it: List>): Condition.And = Condition.And(it)
}

class ConditionOrSerializer(val inner: KSerializer): WrappingSerializer, List>>("Or") {
    override fun getDeferred(): KSerializer>> = ListSerializer(Condition.serializer(inner))
    override fun inner(it: Condition.Or): List> = it.conditions
    override fun outer(it: List>): Condition.Or = Condition.Or(it)
}

class ConditionNotSerializer(val inner: KSerializer) : WrappingSerializer, Condition>("Not") {
    override fun getDeferred(): KSerializer> = Condition.serializer(inner)
    override fun inner(it: Condition.Not): Condition = it.condition
    override fun outer(it: Condition): Condition.Not = Condition.Not(it)
}

class ConditionEqualSerializer(val inner: KSerializer) : WrappingSerializer, T>("Equal") {
    override fun getDeferred(): KSerializer = inner
    override fun inner(it: Condition.Equal): T = it.value
    override fun outer(it: T): Condition.Equal = Condition.Equal(it)
}

class ConditionNotEqualSerializer(val inner: KSerializer) : WrappingSerializer, T>("NotEqual") {
    override fun getDeferred(): KSerializer = inner
    override fun inner(it: Condition.NotEqual): T = it.value
    override fun outer(it: T): Condition.NotEqual = Condition.NotEqual(it)
}

class ConditionInsideSerializer(val inner: KSerializer) : WrappingSerializer, List>("Inside") {
    override fun getDeferred() = ListSerializer(inner)
    override fun inner(it: Condition.Inside): List = it.values
    override fun outer(it: List) = Condition.Inside(it)
}

class ConditionNotInsideSerializer(val inner: KSerializer) : WrappingSerializer, List>("NotInside") {
    override fun getDeferred() = ListSerializer(inner)
    override fun inner(it: Condition.NotInside): List = it.values
    override fun outer(it: List) = Condition.NotInside(it)
}

class ConditionGreaterThanSerializer>(val inner: KSerializer) : WrappingSerializer, T>("GreaterThan") {
    override fun getDeferred() = inner
    override fun inner(it: Condition.GreaterThan): T = it.value
    override fun outer(it: T) = Condition.GreaterThan(it)
}

class ConditionLessThanSerializer>(val inner: KSerializer) : WrappingSerializer, T>("LessThan") {
    override fun getDeferred() = inner
    override fun inner(it: Condition.LessThan): T = it.value
    override fun outer(it: T) = Condition.LessThan(it)
}

class ConditionGreaterThanOrEqualSerializer>(val inner: KSerializer) : WrappingSerializer, T>("GreaterThanOrEqual") {
    override fun getDeferred() = inner
    override fun inner(it: Condition.GreaterThanOrEqual): T = it.value
    override fun outer(it: T) = Condition.GreaterThanOrEqual(it)
}

class ConditionLessThanOrEqualSerializer>(val inner: KSerializer) : WrappingSerializer, T>("LessThanOrEqual") {
    override fun getDeferred() = inner
    override fun inner(it: Condition.LessThanOrEqual): T = it.value
    override fun outer(it: T) = Condition.LessThanOrEqual(it)
}

object ConditionIntBitsClearSerializer : WrappingSerializer("IntBitsClear") {
    override fun getDeferred() = Int.serializer()
    override fun inner(it: Condition.IntBitsClear): Int = it.mask
    override fun outer(it: Int): Condition.IntBitsClear = Condition.IntBitsClear(it)
}

object ConditionIntBitsSetSerializer : WrappingSerializer("IntBitsSet") {
    override fun getDeferred() = Int.serializer()
    override fun inner(it: Condition.IntBitsSet): Int = it.mask
    override fun outer(it: Int): Condition.IntBitsSet = Condition.IntBitsSet(it)
}

object ConditionIntBitsAnyClearSerializer : WrappingSerializer("IntBitsAnyClear") {
    override fun getDeferred() = Int.serializer()
    override fun inner(it: Condition.IntBitsAnyClear): Int = it.mask
    override fun outer(it: Int): Condition.IntBitsAnyClear = Condition.IntBitsAnyClear(it)
}

object ConditionIntBitsAnySetSerializer : WrappingSerializer("IntBitsAnySet") {
    override fun getDeferred() = Int.serializer()
    override fun inner(it: Condition.IntBitsAnySet): Int = it.mask
    override fun outer(it: Int): Condition.IntBitsAnySet = Condition.IntBitsAnySet(it)
}

class ConditionListAllElementsSerializer(val inner: KSerializer) : WrappingSerializer, Condition>("ListAllElements") {
    override fun getDeferred(): KSerializer> = Condition.serializer(inner)
    override fun inner(it: Condition.ListAllElements): Condition = it.condition
    override fun outer(it: Condition): Condition.ListAllElements = Condition.ListAllElements(it)
}

class ConditionListAnyElementsSerializer(val inner: KSerializer) : WrappingSerializer, Condition>("ListAnyElements") {
    override fun getDeferred(): KSerializer> = Condition.serializer(inner)
    override fun inner(it: Condition.ListAnyElements): Condition = it.condition
    override fun outer(it: Condition): Condition.ListAnyElements = Condition.ListAnyElements(it)
}

class ConditionListSizesEqualsSerializer(val inner: KSerializer) : WrappingSerializer, Int>("ListSizesEquals") {
    override fun getDeferred() = Int.serializer()
    override fun inner(it: Condition.ListSizesEquals): Int = it.count
    override fun outer(it: Int): Condition.ListSizesEquals = Condition.ListSizesEquals(it)
}

class ConditionSetAllElementsSerializer(val inner: KSerializer) : WrappingSerializer, Condition>("SetAllElements") {
    override fun getDeferred(): KSerializer> = Condition.serializer(inner)
    override fun inner(it: Condition.SetAllElements): Condition = it.condition
    override fun outer(it: Condition): Condition.SetAllElements = Condition.SetAllElements(it)
}

class ConditionSetAnyElementsSerializer(val inner: KSerializer) : WrappingSerializer, Condition>("SetAnyElements") {
    override fun getDeferred(): KSerializer> = Condition.serializer(inner)
    override fun inner(it: Condition.SetAnyElements): Condition = it.condition
    override fun outer(it: Condition): Condition.SetAnyElements = Condition.SetAnyElements(it)
}

class ConditionSetSizesEqualsSerializer(val inner: KSerializer) : WrappingSerializer, Int>("SetSizesEquals") {
    override fun getDeferred() = Int.serializer()
    override fun inner(it: Condition.SetSizesEquals): Int = it.count
    override fun outer(it: Int): Condition.SetSizesEquals = Condition.SetSizesEquals(it)
}

class ConditionExistsSerializer(val inner: KSerializer) : WrappingSerializer, String>("Exists") {
    override fun getDeferred(): KSerializer = serializer()
    override fun inner(it: Condition.Exists): String = it.key
    override fun outer(it: String): Condition.Exists = Condition.Exists(it)
}

class ConditionIfNotNullSerializer(val inner: KSerializer) : WrappingSerializer, Condition>("IfNotNull") {
    override fun getDeferred(): KSerializer> = Condition.serializer(inner)
    override fun inner(it: Condition.IfNotNull): Condition = it.condition
    override fun outer(it: Condition): Condition.IfNotNull = Condition.IfNotNull(it)
}