Refactor unit objects

data/model/src/main/java/com/sadellie/unitto/data/model/unit/AbstractUnit.kt

@@ -32,6 +32,17 @@ interface AbstractUnit {
     val isFavorite: Boolean
     val pairId: String?
     val counter: Int
+
+    fun clone(
+        id: String = this.id,
+        basicUnit: BigDecimal = this.basicUnit,
+        group: UnitGroup = this.group,
+        displayName: Int = this.displayName,
+        shortName: Int = this.shortName,
+        isFavorite: Boolean = this.isFavorite,
+        pairId: String? = this.pairId,
+        counter: Int = this.counter,
+    ): AbstractUnit
 }
 
 fun Sequence<AbstractUnit>.filterByLev(stringA: String, context: Context): Sequence<AbstractUnit> {

data/model/src/main/java/com/sadellie/unitto/data/model/unit/FuelBackward.kt

@@ -53,4 +53,24 @@ data class FuelBackward(
             else -> BigDecimal.ZERO
         }
     }
+
+    override fun clone(
+        id: String,
+        basicUnit: BigDecimal,
+        group: UnitGroup,
+        displayName: Int,
+        shortName: Int,
+        isFavorite: Boolean,
+        pairId: String?,
+        counter: Int,
+    ): FuelBackward = copy(
+        id = id,
+        basicUnit = basicUnit,
+        group = group,
+        displayName = displayName,
+        shortName = shortName,
+        isFavorite = isFavorite,
+        pairId = pairId,
+        counter = counter,
+    )
 }

data/model/src/main/java/com/sadellie/unitto/data/model/unit/FuelForward.kt

@@ -52,4 +52,24 @@ data class FuelForward(
             else -> BigDecimal.ZERO
         }
     }
+
+    override fun clone(
+        id: String,
+        basicUnit: BigDecimal,
+        group: UnitGroup,
+        displayName: Int,
+        shortName: Int,
+        isFavorite: Boolean,
+        pairId: String?,
+        counter: Int,
+    ): FuelForward = copy(
+        id = id,
+        basicUnit = basicUnit,
+        group = group,
+        displayName = displayName,
+        shortName = shortName,
+        isFavorite = isFavorite,
+        pairId = pairId,
+        counter = counter,
+    )
 }

data/model/src/main/java/com/sadellie/unitto/data/model/unit/NormalUnit.kt

@@ -43,4 +43,24 @@ data class NormalUnit(
             .multiply(value)
             .div(unitTo.basicUnit)
     }
+
+    override fun clone(
+        id: String,
+        basicUnit: BigDecimal,
+        group: UnitGroup,
+        displayName: Int,
+        shortName: Int,
+        isFavorite: Boolean,
+        pairId: String?,
+        counter: Int,
+    ): NormalUnit = copy(
+        id = id,
+        basicUnit = basicUnit,
+        group = group,
+        displayName = displayName,
+        shortName = shortName,
+        isFavorite = isFavorite,
+        pairId = pairId,
+        counter = counter,
+    )
 }

data/model/src/main/java/com/sadellie/unitto/data/model/unit/NumberBaseUnit.kt

@@ -34,4 +34,24 @@ data class NumberBaseUnit(
     fun convert(toBase: NumberBaseUnit, input: String): String {
         return input.toBigInteger(basicUnit.intValueExact()).toString(toBase.basicUnit.intValueExact())
     }
+
+    override fun clone(
+        id: String,
+        basicUnit: BigDecimal,
+        group: UnitGroup,
+        displayName: Int,
+        shortName: Int,
+        isFavorite: Boolean,
+        pairId: String?,
+        counter: Int,
+    ): NumberBaseUnit = copy(
+        id = id,
+        basicUnit = basicUnit,
+        group = group,
+        displayName = displayName,
+        shortName = shortName,
+        isFavorite = isFavorite,
+        pairId = pairId,
+        counter = counter,
+    )
 }

data/model/src/main/java/com/sadellie/unitto/data/model/unit/ReverseUnit.kt

@@ -41,4 +41,24 @@ data class ReverseUnit(
             .div(this.basicUnit)
             .multiply(value)
     }
+
+    override fun clone(
+        id: String,
+        basicUnit: BigDecimal,
+        group: UnitGroup,
+        displayName: Int,
+        shortName: Int,
+        isFavorite: Boolean,
+        pairId: String?,
+        counter: Int,
+    ): ReverseUnit = copy(
+        id = id,
+        basicUnit = basicUnit,
+        group = group,
+        displayName = displayName,
+        shortName = shortName,
+        isFavorite = isFavorite,
+        pairId = pairId,
+        counter = counter,
+    )
 }

data/model/src/main/java/com/sadellie/unitto/data/model/unit/TemperatureUnit.kt

@@ -0,0 +1,56 @@
+/*
+ * Unitto is a unit converter for Android
+ * Copyright (c) 2023 Elshan Agaev
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.sadellie.unitto.data.model.unit
+
+import com.sadellie.unitto.data.model.UnitGroup
+import java.math.BigDecimal
+
+data class TemperatureUnit(
+    override val id: String,
+    override val basicUnit: BigDecimal,
+    override val group: UnitGroup,
+    override val displayName: Int,
+    override val shortName: Int,
+    override val isFavorite: Boolean = false,
+    override val pairId: String? = null,
+    override val counter: Int = 0,
+    val customConvert: (unitTo: DefaultUnit, value: BigDecimal) -> BigDecimal
+): DefaultUnit {
+    override fun convert(unitTo: DefaultUnit, value: BigDecimal): BigDecimal = customConvert(unitTo, value)
+
+    override fun clone(
+        id: String,
+        basicUnit: BigDecimal,
+        group: UnitGroup,
+        displayName: Int,
+        shortName: Int,
+        isFavorite: Boolean,
+        pairId: String?,
+        counter: Int,
+    ): TemperatureUnit = copy(
+        id = id,
+        basicUnit = basicUnit,
+        group = group,
+        displayName = displayName,
+        shortName = shortName,
+        isFavorite = isFavorite,
+        pairId = pairId,
+        counter = counter,
+    )
+}

data/units/src/main/java/com/sadellie/unitto/data/units/UnitsRepository.kt

@@ -27,10 +27,6 @@ import com.sadellie.unitto.data.database.UnitsEntity
 import com.sadellie.unitto.data.model.UnitGroup
 import com.sadellie.unitto.data.model.UnitsListSorting
 import com.sadellie.unitto.data.model.unit.AbstractUnit
-import com.sadellie.unitto.data.model.unit.FuelBackward
-import com.sadellie.unitto.data.model.unit.FuelForward
-import com.sadellie.unitto.data.model.unit.NormalUnit
-import com.sadellie.unitto.data.model.unit.NumberBaseUnit
 import com.sadellie.unitto.data.model.unit.ReverseUnit
 import com.sadellie.unitto.data.model.unit.filterByLev
 import com.sadellie.unitto.data.units.collections.accelerationCollection
@@ -113,40 +109,13 @@ class UnitsRepository @Inject constructor(
         .mapLatest { basedList ->
             basedList.forEach { based ->
                 // Have to use a copy so that composable can detect changes
-                val updatedUnit = when (val foundUnit = getById(based.unitId)) {
+                val updatedUnit = getById(based.unitId)
-                    is NormalUnit -> foundUnit.copy(
+                    .clone(
                         isFavorite = based.isFavorite,
                         counter = based.frequency,
                         pairId = based.pairedUnitId
                     )
 
-                    is NumberBaseUnit -> foundUnit.copy(
-                        isFavorite = based.isFavorite,
-                        counter = based.frequency,
-                        pairId = based.pairedUnitId
-                    )
-
-                    is ReverseUnit -> foundUnit.copy(
-                        isFavorite = based.isFavorite,
-                        counter = based.frequency,
-                        pairId = based.pairedUnitId
-                    )
-
-                    is FuelForward -> foundUnit.copy(
-                        isFavorite = based.isFavorite,
-                        counter = based.frequency,
-                        pairId = based.pairedUnitId
-                    )
-
-                    is FuelBackward -> foundUnit.copy(
-                        isFavorite = based.isFavorite,
-                        counter = based.frequency,
-                        pairId = based.pairedUnitId
-                    )
-
-                    else -> return@forEach
-                }
-
                 myUnits.update { units ->
                     units.replace(updatedUnit) { it.id == updatedUnit.id }
                 }

data/units/src/main/java/com/sadellie/unitto/data/units/collections/Temperature.kt

@@ -22,102 +22,88 @@ import com.sadellie.unitto.core.base.MAX_PRECISION
 import com.sadellie.unitto.core.base.R
 import com.sadellie.unitto.data.model.UnitGroup
 import com.sadellie.unitto.data.model.unit.AbstractUnit
-import com.sadellie.unitto.data.model.unit.DefaultUnit
+import com.sadellie.unitto.data.model.unit.TemperatureUnit
 import com.sadellie.unitto.data.units.MyUnitIDS
 import java.math.BigDecimal
 import java.math.RoundingMode
 
 internal val temperatureCollection: List<AbstractUnit> by lazy {
-    listOf(Celsius, Fahrenheit, Kelvin)
+    listOf(
-}
+        TemperatureUnit(
-
+            id = MyUnitIDS.celsius,
-private data object Celsius : DefaultUnit {
+            basicUnit = BigDecimal.ONE,
-    override val id: String = MyUnitIDS.celsius
+            group = UnitGroup.TEMPERATURE,
-    override val basicUnit: BigDecimal = BigDecimal.ONE
+            displayName = R.string.celsius,
-    override val group: UnitGroup = UnitGroup.TEMPERATURE
+            shortName = R.string.celsius_short,
-    override val displayName: Int = R.string.celsius
+            customConvert = { unitTo, value ->
-    override val shortName: Int = R.string.celsius_short
+                when (unitTo.id) {
-    override val isFavorite: Boolean = false
+                    MyUnitIDS.fahrenheit -> {
-    override val pairId: String? = null
+                        value
-    override val counter: Int = 0
+                            .setScale(MAX_PRECISION, RoundingMode.HALF_EVEN)
-
+                            .times(BigDecimal.valueOf(1.8))
-    override fun convert(unitTo: DefaultUnit, value: BigDecimal): BigDecimal {
+                            .plus(BigDecimal(32))
-        return when (unitTo.id) {
+                    }
-            MyUnitIDS.fahrenheit -> {
+
-                value
+                    MyUnitIDS.kelvin -> {
-                    .setScale(MAX_PRECISION, RoundingMode.HALF_EVEN)
+                        value
-                    .times(BigDecimal.valueOf(1.8))
+                            .setScale(MAX_PRECISION, RoundingMode.HALF_EVEN)
-                    .plus(BigDecimal(32))
+                            .plus(BigDecimal.valueOf(273.15))
-            }
+                    }
-
+
-            MyUnitIDS.kelvin -> {
+                    else -> value
-                value
+                }
-                    .setScale(MAX_PRECISION, RoundingMode.HALF_EVEN)
+            }
-                    .plus(BigDecimal.valueOf(273.15))
+        ),
-            }
+        TemperatureUnit(
-
+            id = MyUnitIDS.fahrenheit,
-            else -> value
+            basicUnit = BigDecimal.ONE,
-        }
+            group = UnitGroup.TEMPERATURE,
-    }
+            displayName = R.string.fahrenheit,
-}
+            shortName = R.string.fahrenheit_short,
-
+            customConvert = { unitTo, value ->
-private data object Fahrenheit : DefaultUnit {
+                when (unitTo.id) {
-    override val id: String = MyUnitIDS.fahrenheit
+                    MyUnitIDS.celsius -> {
-    override val basicUnit: BigDecimal = BigDecimal.ONE
+                        value
-    override val group: UnitGroup = UnitGroup.TEMPERATURE
+                            .setScale(MAX_PRECISION, RoundingMode.HALF_EVEN)
-    override val displayName: Int = R.string.fahrenheit
+                            .minus(BigDecimal(32))
-    override val shortName: Int = R.string.fahrenheit_short
+                            .times(BigDecimal(5))
-    override val isFavorite: Boolean = false
+                            .div(BigDecimal(9))
-    override val pairId: String? = null
+                    }
-    override val counter: Int = 0
+                    MyUnitIDS.kelvin -> {
-
+                        value
-    override fun convert(unitTo: DefaultUnit, value: BigDecimal): BigDecimal {
+                            .setScale(MAX_PRECISION, RoundingMode.HALF_EVEN)
-        return when (unitTo.id) {
+                            .minus(BigDecimal(32))
-            MyUnitIDS.celsius -> {
+                            .times(BigDecimal(5))
-                value
+                            .div(BigDecimal(9))
-                    .setScale(MAX_PRECISION, RoundingMode.HALF_EVEN)
+                            .add(BigDecimal.valueOf(273.15))
-                    .minus(BigDecimal(32))
+                    }
-                    .times(BigDecimal(5))
+                    else -> value
-                    .div(BigDecimal(9))
+                }
-            }
+            }
-            MyUnitIDS.kelvin -> {
+        ),
-                value
+        TemperatureUnit(
-                    .setScale(MAX_PRECISION, RoundingMode.HALF_EVEN)
+            id = MyUnitIDS.kelvin,
-                    .minus(BigDecimal(32))
+            basicUnit = BigDecimal.ONE,
-                    .times(BigDecimal(5))
+            group = UnitGroup.TEMPERATURE,
-                    .div(BigDecimal(9))
+            displayName = R.string.kelvin,
-                    .add(BigDecimal.valueOf(273.15))
+            shortName = R.string.kelvin_short,
-            }
+            customConvert = { unitTo, value ->
-            else -> value
+                when (unitTo.id) {
-        }
+                    MyUnitIDS.celsius -> {
-    }
+                        value
-}
+                            .setScale(MAX_PRECISION, RoundingMode.HALF_EVEN)
-
+                            .minus(BigDecimal(273.15))
-private data object Kelvin : DefaultUnit {
+                    }
-    override val id: String = MyUnitIDS.kelvin
+                    MyUnitIDS.fahrenheit -> {
-    override val basicUnit: BigDecimal = BigDecimal.ONE
+                        value
-    override val group: UnitGroup = UnitGroup.TEMPERATURE
+                            .setScale(MAX_PRECISION, RoundingMode.HALF_EVEN)
-    override val displayName: Int = R.string.kelvin
+                            .minus(BigDecimal.valueOf(273.15))
-    override val shortName: Int = R.string.kelvin_short
+                            .times(BigDecimal.valueOf(1.8))
-    override val isFavorite: Boolean = false
+                            .plus(BigDecimal(32))
-    override val pairId: String? = null
+                    }
-    override val counter: Int = 0
+                    else -> value
-
+                }
-    override fun convert(unitTo: DefaultUnit, value: BigDecimal): BigDecimal {
+            }
-        return when (unitTo.id) {
+        ),
-            MyUnitIDS.celsius -> {
+    )
-                value
-                    .setScale(MAX_PRECISION, RoundingMode.HALF_EVEN)
-                    .minus(BigDecimal(273.15))
-            }
-            MyUnitIDS.fahrenheit -> {
-                value
-                    .setScale(MAX_PRECISION, RoundingMode.HALF_EVEN)
-                    .minus(BigDecimal.valueOf(273.15))
-                    .times(BigDecimal.valueOf(1.8))
-                    .plus(BigDecimal(32))
-            }
-            else -> value
-        }
-    }
 }