Converted symbols to use BigInteger and made the code smaller

Author: Dr. Brandon Wiley

Codex/src/main/java/org/operatorfoundation/codex/symbols/Binary.kt

@@ -11,16 +11,16 @@ class Binary : Symbol {
 
     override fun decode(encodedValue: ByteArray): BigInteger {
         return when (encodedValue.decodeToString()) {
-            "0" -> 0
-            "1" -> 1
+            "0" -> 0.toBigInteger()
+            "1" -> 1.toBigInteger()
             else -> throw IllegalArgumentException("Binary, bad value $encodedValue")
         }
     }
 
     override fun encode(numericValue: BigInteger): ByteArray {
         return when (numericValue) {
-            0 -> "0".toByteArray()
-            1 -> "1".toByteArray()
+            0.toBigInteger() -> "0".toByteArray()
+            1.toBigInteger() -> "1".toByteArray()
             else -> throw IllegalArgumentException("Unknown value $numericValue for Binary")
         }
     }

Codex/src/main/java/org/operatorfoundation/codex/symbols/Byte.kt

@@ -1,5 +1,7 @@
 package org.operatorfoundation.codex.symbols
 
+import java.math.BigInteger
+
 /**
  * Byte symbol - encodes/decodes byte values (0-255).
  * Used for binary data encoding.
@@ -8,19 +10,19 @@ class Byte : Symbol {
     override fun size() = 256
     override fun toString() = "Byte"
 
-    override fun encode(numericValue: Int): ByteArray {
-        if (numericValue < 0 || numericValue > 255) {
+    override fun encode(numericValue: BigInteger): ByteArray {
+        if (numericValue < 0.toBigInteger() || numericValue > 255.toBigInteger()) {
             throw Exception("Invalid value $numericValue for Byte (must be 0-255)")
         }
-        return numericValue.toChar().toString().toByteArray()
+        return numericValue.toInt().toChar().toString().toByteArray()
     }
 
-    override fun decode(encodedValue: ByteArray): Int {
+    override fun decode(encodedValue: ByteArray): BigInteger {
         if (encodedValue.size != 1)
         {
             throw Exception("Too many bytes")
         }
 
-        return encodedValue[0].toInt()
+        return encodedValue[0].toInt().toBigInteger()
     }
 }

Codex/src/main/java/org/operatorfoundation/codex/symbols/CallAny.kt

@@ -1,15 +1,23 @@
 package org.operatorfoundation.codex.symbols
 
+import java.math.BigInteger
+
 class CallAny : Symbol {
     companion object {
         private val charToValue = mapOf(
-            "A" to 0, "B" to 1, "C" to 2, "D" to 3, "E" to 4, "F" to 5,
-            "G" to 6, "H" to 7, "I" to 8, "J" to 9, "K" to 10, "L" to 11,
-            "M" to 12, "N" to 13, "O" to 14, "P" to 15, "Q" to 16, "R" to 17,
-            "S" to 18, "T" to 19, "U" to 20, "V" to 21, "W" to 22, "X" to 23,
-            "Y" to 24, "Z" to 25, "0" to 26, "1" to 27, "2" to 28, "3" to 29,
-            "4" to 30, "5" to 31, "6" to 32, "7" to 33, "8" to 34, "9" to 35,
-            " " to 36
+            "A" to BigInteger.valueOf(0), "B" to BigInteger.valueOf(1), "C" to BigInteger.valueOf(2),
+            "D" to BigInteger.valueOf(3), "E" to BigInteger.valueOf(4), "F" to BigInteger.valueOf(5),
+            "G" to BigInteger.valueOf(6), "H" to BigInteger.valueOf(7), "I" to BigInteger.valueOf(8),
+            "J" to BigInteger.valueOf(9), "K" to BigInteger.valueOf(10), "L" to BigInteger.valueOf(11),
+            "M" to BigInteger.valueOf(12), "N" to BigInteger.valueOf(13), "O" to BigInteger.valueOf(14),
+            "P" to BigInteger.valueOf(15), "Q" to BigInteger.valueOf(16), "R" to BigInteger.valueOf(17),
+            "S" to BigInteger.valueOf(18), "T" to BigInteger.valueOf(19), "U" to BigInteger.valueOf(20),
+            "V" to BigInteger.valueOf(21), "W" to BigInteger.valueOf(22), "X" to BigInteger.valueOf(23),
+            "Y" to BigInteger.valueOf(24), "Z" to BigInteger.valueOf(25), "0" to BigInteger.valueOf(26),
+            "1" to BigInteger.valueOf(27), "2" to BigInteger.valueOf(28), "3" to BigInteger.valueOf(29),
+            "4" to BigInteger.valueOf(30), "5" to BigInteger.valueOf(31), "6" to BigInteger.valueOf(32),
+            "7" to BigInteger.valueOf(33), "8" to BigInteger.valueOf(34), "9" to BigInteger.valueOf(35),
+            " " to BigInteger.valueOf(36)
         )
 
         private val valueToChar = charToValue.map { (k, v) -> v to k }.toMap()
@@ -19,12 +27,12 @@ class CallAny : Symbol {
 
     override fun toString(): String = "CallAny"
 
-    override fun decode(encodedValue: ByteArray): Int {
+    override fun decode(encodedValue: ByteArray): BigInteger {
         return charToValue[encodedValue.toString()]
             ?: throw IllegalArgumentException("CallAny, bad value: $encodedValue")
     }
 
-    override fun encode(numericValue: Int): ByteArray {
+    override fun encode(numericValue: BigInteger): ByteArray {
         return (valueToChar[numericValue]
             ?: throw IllegalArgumentException("Unknown value $numericValue for CallAny"))
             .toByteArray()

Codex/src/main/java/org/operatorfoundation/codex/symbols/CallLetter.kt

@@ -1,13 +1,18 @@
 package org.operatorfoundation.codex.symbols
+import java.math.BigInteger
 
 class CallLetter : Symbol {
     companion object {
         private val charToValue = mapOf(
-            "A" to 0, "B" to 1, "C" to 2, "D" to 3, "E" to 4, "F" to 5,
-            "G" to 6, "H" to 7, "I" to 8, "J" to 9, "K" to 10, "L" to 11,
-            "M" to 12, "N" to 13, "O" to 14, "P" to 15, "Q" to 16, "R" to 17,
-            "S" to 18, "T" to 19, "U" to 20, "V" to 21, "W" to 22, "X" to 23,
-            "Y" to 24, "Z" to 25
+            "A" to 0.toBigInteger(), "B" to 1.toBigInteger(), "C" to 2.toBigInteger(),
+            "D" to 3.toBigInteger(), "E" to 4.toBigInteger(), "F" to 5.toBigInteger(),
+            "G" to 6.toBigInteger(), "H" to 7.toBigInteger(), "I" to 8.toBigInteger(),
+            "J" to 9.toBigInteger(), "K" to 10.toBigInteger(), "L" to 11.toBigInteger(),
+            "M" to 12.toBigInteger(), "N" to 13.toBigInteger(), "O" to 14.toBigInteger(),
+            "P" to 15.toBigInteger(), "Q" to 16.toBigInteger(), "R" to 17.toBigInteger(),
+            "S" to 18.toBigInteger(), "T" to 19.toBigInteger(), "U" to 20.toBigInteger(),
+            "V" to 21.toBigInteger(), "W" to 22.toBigInteger(), "X" to 23.toBigInteger(),
+            "Y" to 24.toBigInteger(), "Z" to 25.toBigInteger()
         )
 
         private val valueToChar = charToValue.map { (k, v) -> v to k }.toMap()
@@ -17,12 +22,12 @@ class CallLetter : Symbol {
 
     override fun toString(): String = "CallLetter"
 
-    override fun decode(encodedValue: ByteArray): Int {
+    override fun decode(encodedValue: ByteArray): BigInteger {
         return charToValue[encodedValue.toString()]
             ?: throw IllegalArgumentException("CallLetter, bad value: $encodedValue")
     }
 
-    override fun encode(numericValue: Int): ByteArray {
+    override fun encode(numericValue: BigInteger): ByteArray {
         return (valueToChar[numericValue]
             ?: throw IllegalArgumentException("Unknown value $numericValue for CallLetter"))
             .toByteArray()

Codex/src/main/java/org/operatorfoundation/codex/symbols/CallLetterNumber.kt

@@ -1,95 +1,38 @@
 package org.operatorfoundation.codex.symbols
+import java.math.BigInteger
 
 class CallLetterNumber : Symbol {
-    override fun size(): Int {
-        return 26 + 10
-    }
+    companion object {
+        private val charToValue = mapOf(
+            "A" to 0.toBigInteger(), "B" to 1.toBigInteger(), "C" to 2.toBigInteger(),
+            "D" to 3.toBigInteger(), "E" to 4.toBigInteger(), "F" to 5.toBigInteger(),
+            "G" to 6.toBigInteger(), "H" to 7.toBigInteger(), "I" to 8.toBigInteger(),
+            "J" to 9.toBigInteger(), "K" to 10.toBigInteger(), "L" to 11.toBigInteger(),
+            "M" to 12.toBigInteger(), "N" to 13.toBigInteger(), "O" to 14.toBigInteger(),
+            "P" to 15.toBigInteger(), "Q" to 16.toBigInteger(), "R" to 17.toBigInteger(),
+            "S" to 18.toBigInteger(), "T" to 19.toBigInteger(), "U" to 20.toBigInteger(),
+            "V" to 21.toBigInteger(), "W" to 22.toBigInteger(), "X" to 23.toBigInteger(),
+            "Y" to 24.toBigInteger(), "Z" to 25.toBigInteger(), "0" to 26.toBigInteger(),
+            "1" to 27.toBigInteger(), "2" to 28.toBigInteger(), "3" to 29.toBigInteger(),
+            "4" to 30.toBigInteger(), "5" to 31.toBigInteger(), "6" to 32.toBigInteger(),
+            "7" to 33.toBigInteger(), "8" to 34.toBigInteger(), "9" to 35.toBigInteger()
+        )
 
-    override fun toString(): String {
-        return "CallLetterNumber"
+        private val valueToChar = charToValue.map { (k, v) -> v to k }.toMap()
     }
 
-    override fun decode(encodedValue: ByteArray): Int {
-        return when (encodedValue.toString()) {
-            "A" -> 0
-            "B" -> 1
-            "C" -> 2
-            "D" -> 3
-            "E" -> 4
-            "F" -> 5
-            "G" -> 6
-            "H" -> 7
-            "I" -> 8
-            "J" -> 9
-            "K" -> 10
-            "L" -> 11
-            "M" -> 12
-            "N" -> 13
-            "O" -> 14
-            "P" -> 15
-            "Q" -> 16
-            "R" -> 17
-            "S" -> 18
-            "T" -> 19
-            "U" -> 20
-            "V" -> 21
-            "W" -> 22
-            "X" -> 23
-            "Y" -> 24
-            "Z" -> 25
-            "0" -> 26
-            "1" -> 27
-            "2" -> 28
-            "3" -> 29
-            "4" -> 30
-            "5" -> 31
-            "6" -> 32
-            "7" -> 33
-            "8" -> 34
-            "9" -> 35
-            else -> throw IllegalArgumentException("CallLetterNumber, bad value: $encodedValue")
-        }
+    override fun size(): Int = 26 + 10
+
+    override fun toString(): String = "CallLetterNumber"
+
+    override fun decode(encodedValue: ByteArray): BigInteger {
+        return charToValue[encodedValue.toString()]
+            ?: throw IllegalArgumentException("CallLetterNumber, bad value: $encodedValue")
     }
 
-    override fun encode(numericValue: Int): ByteArray {
-        return when (numericValue) {
-            0 -> "A".toByteArray()
-            1 -> "B".toByteArray()
-            2 -> "C".toByteArray()
-            3 -> "D".toByteArray()
-            4 -> "E".toByteArray()
-            5 -> "F".toByteArray()
-            6 -> "G".toByteArray()
-            7 -> "H".toByteArray()
-            8 -> "I".toByteArray()
-            9 -> "J".toByteArray()
-            10 -> "K".toByteArray()
-            11 -> "L".toByteArray()
-            12 -> "M".toByteArray()
-            13 -> "N".toByteArray()
-            14 -> "O".toByteArray()
-            15 -> "P".toByteArray()
-            16 -> "Q".toByteArray()
-            17 -> "R".toByteArray()
-            18 -> "S".toByteArray()
-            19 -> "T".toByteArray()
-            20 -> "U".toByteArray()
-            21 -> "V".toByteArray()
-            22 -> "W".toByteArray()
-            23 -> "X".toByteArray()
-            24 -> "Y".toByteArray()
-            25 -> "Z".toByteArray()
-            26 -> "0".toByteArray()
-            27 -> "1".toByteArray()
-            28 -> "2".toByteArray()
-            29 -> "3".toByteArray()
-            30 -> "4".toByteArray()
-            31 -> "5".toByteArray()
-            32 -> "6".toByteArray()
-            33 -> "7".toByteArray()
-            34 -> "8".toByteArray()
-            35 -> "9".toByteArray()
-            else -> throw IllegalArgumentException("Unknown value $numericValue for CallLetterNumber")
-        }
+    override fun encode(numericValue: BigInteger): ByteArray {
+        return (valueToChar[numericValue]
+            ?: throw IllegalArgumentException("Unknown value $numericValue for CallLetterNumber"))
+            .toByteArray()
     }
 }

Codex/src/main/java/org/operatorfoundation/codex/symbols/CallLetterSpace.kt

@@ -1,78 +1,35 @@
 package org.operatorfoundation.codex.symbols
+import java.math.BigInteger
 
 class CallLetterSpace : Symbol {
-    override fun size(): Int
-    {
-        return 27
-    }
+    companion object {
+        private val charToValue = mapOf(
+            "A" to 0.toBigInteger(), "B" to 1.toBigInteger(), "C" to 2.toBigInteger(),
+            "D" to 3.toBigInteger(), "E" to 4.toBigInteger(), "F" to 5.toBigInteger(),
+            "G" to 6.toBigInteger(), "H" to 7.toBigInteger(), "I" to 8.toBigInteger(),
+            "J" to 9.toBigInteger(), "K" to 10.toBigInteger(), "L" to 11.toBigInteger(),
+            "M" to 12.toBigInteger(), "N" to 13.toBigInteger(), "O" to 14.toBigInteger(),
+            "P" to 15.toBigInteger(), "Q" to 16.toBigInteger(), "R" to 17.toBigInteger(),
+            "S" to 18.toBigInteger(), "T" to 19.toBigInteger(), "U" to 20.toBigInteger(),
+            "V" to 21.toBigInteger(), "W" to 22.toBigInteger(), "X" to 23.toBigInteger(),
+            "Y" to 24.toBigInteger(), "Z" to 25.toBigInteger(), " " to 26.toBigInteger()
+        )
 
-    override fun toString(): String {
-        return "CallLetterSpace"
+        private val valueToChar = charToValue.map { (k, v) -> v to k }.toMap()
     }
 
-    override fun decode(encodedValue: ByteArray): Int {
-        return when (encodedValue.toString()) {
-            "A" -> 0
-            "B" -> 1
-            "C" -> 2
-            "D" -> 3
-            "E" -> 4
-            "F" -> 5
-            "G" -> 6
-            "H" -> 7
-            "I" -> 8
-            "J" -> 9
-            "K" -> 10
-            "L" -> 11
-            "M" -> 12
-            "N" -> 13
-            "O" -> 14
-            "P" -> 15
-            "Q" -> 16
-            "R" -> 17
-            "S" -> 18
-            "T" -> 19
-            "U" -> 20
-            "V" -> 21
-            "W" -> 22
-            "X" -> 23
-            "Y" -> 24
-            "Z" -> 25
-            " " -> 26
-            else -> throw IllegalArgumentException("CallLetterSpace, bad value: $encodedValue")
-        }
+    override fun size(): Int = 27
+
+    override fun toString(): String = "CallLetterSpace"
+
+    override fun decode(encodedValue: ByteArray): BigInteger {
+        return charToValue[encodedValue.toString()]
+            ?: throw IllegalArgumentException("CallLetterSpace, bad value: $encodedValue")
     }
 
-    override fun encode(numericValue: Int): ByteArray {
-        return when (numericValue) {
-            0 -> "A".toByteArray()
-            1 -> "B".toByteArray()
-            2 -> "C".toByteArray()
-            3 -> "D".toByteArray()
-            4 -> "E".toByteArray()
-            5 -> "F".toByteArray()
-            6 -> "G".toByteArray()
-            7 -> "H".toByteArray()
-            8 -> "I".toByteArray()
-            9 -> "J".toByteArray()
-            10 -> "K".toByteArray()
-            11 -> "L".toByteArray()
-            12 -> "M".toByteArray()
-            13 -> "N".toByteArray()
-            14 -> "O".toByteArray()
-            15 -> "P".toByteArray()
-            16 -> "Q".toByteArray()
-            17 -> "R".toByteArray()
-            18 -> "S".toByteArray()
-            19 -> "T".toByteArray()
-            20 -> "U".toByteArray()
-            21 -> "V".toByteArray()
-            22 -> "W".toByteArray()
-            23 -> "X".toByteArray()
-            24 -> "Y".toByteArray()
-            25 -> "Z".toByteArray()
-            26 -> " ".toByteArray()
-            else -> throw IllegalArgumentException("Unknown value $numericValue for CallLetterSpace")
-        }
+    override fun encode(numericValue: BigInteger): ByteArray {
+        return (valueToChar[numericValue]
+            ?: throw IllegalArgumentException("Unknown value $numericValue for CallLetterSpace"))
+            .toByteArray()
     }
 }