Merge pull request #391 from kleis-technology/refactor/register

Refactor/register
kleis-technology · Oct 27, 2023 · 4c3c616 · 4c3c616
2 parents 14f2dcc + 1f320c6
commit 4c3c616
Show file tree

Hide file tree

Showing 35 changed files with 471 additions and 480 deletions.
diff --git a/core/src/main/kotlin/ch/kleis/lcaac/core/lang/Index.kt b/core/src/main/kotlin/ch/kleis/lcaac/core/lang/Index.kt
@@ -1,41 +1,27 @@
 package ch.kleis.lcaac.core.lang
 
 import arrow.optics.Fold
+import ch.kleis.lcaac.core.lang.register.Register
 
-interface IndexKeySerializer<K> {
-    fun serialize(key: K): String
-}
-
-class Index<K, E> private constructor(
-    private val indexType: String,
-    private val indexKeySerializer: IndexKeySerializer<K>,
-    private val cachedEntries: Map<String, List<E>>,
-    private val optics: Fold<E, K>,
+class Index<S, K, E> private constructor(
+    private val cachedEntries: Map<S, List<E>>,
 ) {
     constructor(
-        register: Register<E>,
-        indexKeySerializer: IndexKeySerializer<K>,
-        optics: Fold<E, K>
+        register: Register<K, E>,
+        optics: Fold<E, S>
     ) : this(
-        register.registerType,
-        indexKeySerializer,
-        register.getEntries(optics).mapKeys { indexKeySerializer.serialize(it.key) },
-        optics,
+        register.getEntries(optics),
     )
 
-    fun firstOrNull(key: K): E? {
-        val h = indexKeySerializer.serialize(key)
-        return cachedEntries[h]?.firstOrNull {
-            this.optics.firstOrNull(it) == key
-        }
+    fun firstOrNull(s: S): E? {
+        return cachedEntries[s]?.firstOrNull()
     }
 
-    fun getAll(key: K): List<E> {
-        return cachedEntries[indexKeySerializer.serialize(key)] ?: emptyList()
+    fun getAll(s: S): List<E> {
+        return cachedEntries[s] ?: emptyList()
     }
 
     override fun toString(): String {
-        return "[index<${indexType}>]"
+        return "[index]"
     }
-
 }
diff --git a/core/src/main/kotlin/ch/kleis/lcaac/core/lang/Register.kt b/core/src/main/kotlin/ch/kleis/lcaac/core/lang/Register.kt
diff --git a/core/src/main/kotlin/ch/kleis/lcaac/core/lang/SymbolTable.kt b/core/src/main/kotlin/ch/kleis/lcaac/core/lang/SymbolTable.kt
@@ -1,33 +1,15 @@
 package ch.kleis.lcaac.core.lang
 
 import arrow.optics.Every
-import arrow.optics.Fold
-import arrow.typeclasses.Monoid
-import ch.kleis.lcaac.core.lang.dimension.Dimension
 import ch.kleis.lcaac.core.lang.expression.*
-import kotlinx.serialization.Serializable
-import kotlinx.serialization.encodeToString
-import kotlinx.serialization.json.Json
-
-@Serializable
-private data class ProcessKey(
-    val name: String,
-    val labels: Map<String, String>,
-)
-
-@Serializable
-private data class SubstanceKey(
-    val name: String,
-    val type: String?,
-    val compartment: String?,
-    val subCompartment: String?,
-)
+import ch.kleis.lcaac.core.lang.register.*
+
 
 data class SymbolTable<Q>(
-    val data: Register<DataExpression<Q>> = Register.empty(),
-    val dimensions: Register<Dimension> = Register.empty(),
-    val processTemplates: Register<EProcessTemplate<Q>> = Register.empty(),
-    val substanceCharacterizations: Register<ESubstanceCharacterization<Q>> = Register.empty(),
+    val data: DataRegister<Q> = DataRegister.empty(),
+    val dimensions: DimensionRegister = DimensionRegister.empty(),
+    val processTemplates: ProcessTemplateRegister<Q> = ProcessTemplateRegister.empty(),
+    val substanceCharacterizations: SubstanceCharacterizationRegister<Q> = SubstanceCharacterizationRegister.empty(),
 ) {
     companion object {
         fun <Q> empty() = SymbolTable<Q>()
@@ -43,57 +25,20 @@ data class SymbolTable<Q>(
         Templates
      */
 
-    private val processKeyDescriptor = object : IndexKeySerializer<ProcessKey> {
-        override fun serialize(key: ProcessKey): String {
-            return Json.encodeToString(key)
-        }
-    }
-    private val processKeyOptics = object : Fold<EProcess<Q>, ProcessKey> {
-        override fun <R> foldMap(M: Monoid<R>, source: EProcess<Q>, map: (focus: ProcessKey) -> R): R {
-            return map(
-                ProcessKey(
-                    source.name,
-                    source.labels.mapValues { it.value.value }
-                )
-            )
-        }
-
-    }
-    private val templatesIndexedByProcessKey: Index<ProcessKey, EProcessTemplate<Q>> = Index(
+    private val templatesIndexedByProductName: Index<String, ProcessKey, EProcessTemplate<Q>> = Index(
         processTemplates,
-        processKeyDescriptor,
-        EProcessTemplate.body<Q>() compose processKeyOptics,
-    )
-
-    private val stringDescriptor = object : IndexKeySerializer<String> {
-        override fun serialize(key: String): String {
-            return key
-        }
-    }
-    private val templatesIndexedByProductName: Index<String, EProcessTemplate<Q>> = Index(
-        processTemplates,
-        stringDescriptor,
         EProcessTemplate.body<Q>().products() compose
             Every.list() compose
             ETechnoExchange.product() compose
             EProductSpec.name()
     )
 
     fun getTemplate(name: String): EProcessTemplate<Q>? {
-        return templatesIndexedByProcessKey.firstOrNull(
-            ProcessKey(
-                name,
-                emptyMap(),
-            )
-        )
+        return processTemplates[ProcessKey(name)]
     }
 
     fun getTemplate(name: String, labels: Map<String, String>): EProcessTemplate<Q>? {
-        return templatesIndexedByProcessKey.firstOrNull(
-            ProcessKey(
-                name, labels
-            )
-        )
+        return processTemplates[ProcessKey(name, labels)]
     }
 
     fun getAllTemplatesByProductName(name: String): List<EProcessTemplate<Q>> {
@@ -104,64 +49,21 @@ data class SymbolTable<Q>(
     /*
         Substances
      */
-    private val substanceKeyDescriptor = object : IndexKeySerializer<SubstanceKey> {
-        override fun serialize(key: SubstanceKey): String {
-            return Json.encodeToString(key)
-        }
-    }
-    private val substanceKeyOptics = object : Fold<ESubstanceSpec<Q>, SubstanceKey> {
-        override fun <R> foldMap(M: Monoid<R>, source: ESubstanceSpec<Q>, map: (focus: SubstanceKey) -> R): R {
-            return map(
-                SubstanceKey(
-                    source.name,
-                    source.type?.value,
-                    source.compartment,
-                    source.subCompartment,
-                )
-            )
-        }
-    }
-    private val substanceCharacterizationsIndexedBySubstanceKey: Index<SubstanceKey, ESubstanceCharacterization<Q>> =
-        Index(
-            substanceCharacterizations,
-            substanceKeyDescriptor,
-            ESubstanceCharacterization.referenceExchange<Q>().substance() compose substanceKeyOptics,
-        )
-
-
-    fun getData(name: String): DataExpression<Q>? {
-        return data[name]
-    }
-
     fun getSubstanceCharacterization(
         name: String,
         type: SubstanceType,
-        compartment: String
+        compartment: String,
+        subCompartment: String? = null,
     ): ESubstanceCharacterization<Q>? {
-        return substanceCharacterizationsIndexedBySubstanceKey.firstOrNull(
-            SubstanceKey(
-                name,
-                type.value,
-                compartment,
-                null,
-            )
-        )
+        return substanceCharacterizations[SubstanceKey(name, type, compartment, subCompartment)]
     }
 
-    fun getSubstanceCharacterization(
-        name: String,
-        type: SubstanceType,
-        compartment: String,
-        subCompartment: String
-    ): ESubstanceCharacterization<Q>? {
-        return substanceCharacterizationsIndexedBySubstanceKey.firstOrNull(
-            SubstanceKey(
-                name,
-                type.value,
-                compartment,
-                subCompartment,
-            )
-        )
+    /*
+        Data
+     */
+    fun getData(name: String): DataExpression<Q>? {
+        return data[DataKey(name)]
     }
+
 }
 
diff --git a/core/src/main/kotlin/ch/kleis/lcaac/core/lang/evaluator/reducer/DataExpressionReducer.kt b/core/src/main/kotlin/ch/kleis/lcaac/core/lang/evaluator/reducer/DataExpressionReducer.kt
@@ -1,17 +1,18 @@
 package ch.kleis.lcaac.core.lang.evaluator.reducer
 
-import ch.kleis.lcaac.core.lang.Register
+import ch.kleis.lcaac.core.lang.register.DataKey
+import ch.kleis.lcaac.core.lang.register.DataRegister
 import ch.kleis.lcaac.core.lang.dimension.UnitSymbol
 import ch.kleis.lcaac.core.lang.evaluator.EvaluatorException
 import ch.kleis.lcaac.core.lang.expression.*
 import ch.kleis.lcaac.core.math.QuantityOperations
 import kotlin.math.pow
 
 class DataExpressionReducer<Q>(
-    dataRegister: Register<DataExpression<Q>>,
+    dataRegister: DataRegister<Q>,
     private val ops: QuantityOperations<Q>,
 ) : Reducer<DataExpression<Q>> {
-    private val dataRegister = Register(dataRegister)
+    private val dataRegister = DataRegister(dataRegister)
     private val infiniteUnitLoopChecker = InfiniteUnitLoopChecker<Q>()
 
     override fun reduce(expression: DataExpression<Q>): DataExpression<Q> {
@@ -132,7 +133,8 @@ class DataExpressionReducer<Q>(
     }
 
     private fun reduceRef(expression: EDataRef<Q>): DataExpression<Q> {
-        return dataRegister[expression.name]?.let { reduce(it) } ?: expression
+        val key = DataKey(expression.name)
+        return dataRegister[key]?.let { reduce(it) } ?: expression
     }
 
     private fun reduceScale(expression: EQuantityScale<Q>): DataExpression<Q> {

diff --git a/core/src/main/kotlin/ch/kleis/lcaac/core/lang/evaluator/reducer/LcaExpressionReducer.kt b/core/src/main/kotlin/ch/kleis/lcaac/core/lang/evaluator/reducer/LcaExpressionReducer.kt
@@ -1,11 +1,11 @@
 package ch.kleis.lcaac.core.lang.evaluator.reducer
 
-import ch.kleis.lcaac.core.lang.Register
+import ch.kleis.lcaac.core.lang.register.DataRegister
 import ch.kleis.lcaac.core.lang.expression.*
 import ch.kleis.lcaac.core.math.QuantityOperations
 
 class LcaExpressionReducer<Q>(
-    dataRegister: Register<DataExpression<Q>> = Register.empty(),
+    dataRegister: DataRegister<Q> = DataRegister.empty(),
     ops: QuantityOperations<Q>,
 ) : Reducer<LcaExpression<Q>> {
     private val dataExpressionReducer = DataExpressionReducer(dataRegister, ops)

diff --git a/core/src/main/kotlin/ch/kleis/lcaac/core/lang/evaluator/reducer/TemplateExpressionReducer.kt b/core/src/main/kotlin/ch/kleis/lcaac/core/lang/evaluator/reducer/TemplateExpressionReducer.kt
@@ -1,15 +1,17 @@
 package ch.kleis.lcaac.core.lang.evaluator.reducer
 
 import arrow.optics.Every
-import ch.kleis.lcaac.core.lang.Register
+import ch.kleis.lcaac.core.lang.register.DataKey
+import ch.kleis.lcaac.core.lang.register.DataRegister
+import ch.kleis.lcaac.core.lang.register.Register
 import ch.kleis.lcaac.core.lang.evaluator.EvaluatorException
 import ch.kleis.lcaac.core.lang.evaluator.Helper
 import ch.kleis.lcaac.core.lang.expression.*
 import ch.kleis.lcaac.core.math.QuantityOperations
 
 class TemplateExpressionReducer<Q>(
     private val ops: QuantityOperations<Q>,
-    dataRegister: Register<DataExpression<Q>> = Register.empty(),
+    dataRegister: DataRegister<Q> = DataRegister.empty(),
 ) : Reducer<ProcessTemplateExpression<Q>> {
     private val dataRegister = Register(dataRegister)
     private val helper = Helper<Q>()
@@ -37,9 +39,9 @@ class TemplateExpressionReducer<Q>(
         val actualArguments = template.params
             .plus(expression.arguments)
 
-        val localRegister = Register(dataRegister)
-            .plus(actualArguments)
-            .plus(template.locals)
+        val localRegister = DataRegister(dataRegister)
+            .plus(actualArguments.mapKeys { DataKey(it.key) })
+            .plus(template.locals.mapKeys { DataKey(it.key) })
 
         val reducer = LcaExpressionReducer(localRegister, ops)
         val dataReducer = DataExpressionReducer(localRegister, ops)