commonMain.maryk.core.definitions.RootMaryk.kt Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of core-jvm Show documentation

Maryk is a Kotlin Multiplatform library which helps you to store, query and send data in a structured way over multiple platforms. The data store stores any value with a version, so it is possible to request only the changed data or live listen for updates.

The newest version!

package maryk.core.definitions

import maryk.core.models.SingleTypedValueDataModel
import maryk.core.properties.definitions.EmbeddedObjectDefinition
import maryk.core.properties.definitions.InternalMultiTypeDefinition
import maryk.core.properties.definitions.contextual.ContextTransformerDefinition
import maryk.core.properties.definitions.list
import maryk.core.properties.types.TypedValue
import maryk.core.query.DefinitionsContext
import maryk.core.query.DefinitionsConversionContext
import maryk.core.query.RequestContext
import maryk.core.query.requests.IsOperation
import maryk.core.query.requests.Requests
import maryk.core.values.ObjectValues

/** Root Maryk element for multiple definitions or requests */
data class RootMaryk(
    val operations: List> = listOf()
) {
    companion object :
        SingleTypedValueDataModel>, RootMaryk, Companion, DefinitionsContext>(
            singlePropertyDefinitionGetter = { Companion.operations }
        ) {
        val operations by list(
            index = 1u,
            getter = RootMaryk::operations,
            valueDefinition = InternalMultiTypeDefinition(
                typeEnum = Operation,
                definitionMap = mapOf(
                    Operation.Define to ContextTransformerDefinition(
                        definition = EmbeddedObjectDefinition(
                            dataModel = { Definitions }
                        ),
                        contextTransformer = {
                            it?.let { modelContext ->
                                DefinitionsConversionContext(modelContext)
                            }
                        }
                    ),
                    Operation.Request to ContextTransformerDefinition(
                        definition = EmbeddedObjectDefinition(
                            dataModel = { Requests }
                        ),
                        contextTransformer = {
                            it?.let { modelContext ->
                                RequestContext(modelContext)
                            }
                        }
                    )
                )
            )
        )

        override fun invoke(values: ObjectValues) = RootMaryk(
            operations = values(1u)
        )
    }
}