style: applied formatting

Author: rasros

README.md

@@ -27,8 +27,8 @@ KEncode provides three standalone entry points:
 
 1. **ByteEncoding** text codecs: Base62, Base36, Base64, and Base85 encoders
    for raw binary data.
-2. **PackedFormat**: A binary format serializer that supports nested objects, 
-   lists, and maps. It uses bitsets for booleans and nullability to minimize 
+2. **PackedFormat**: A binary format serializer that supports nested objects,
+   lists, and maps. It uses bitsets for booleans and nullability to minimize
    overhead.
 3. **EncodedFormat**: A string format serializer that wraps the above to produce
    small deterministic string identifiers.
@@ -41,7 +41,7 @@ dependencies {
 }
 ```
 
-For PackedFormat and EncodedFormat you also need to load the 
+For PackedFormat and EncodedFormat you also need to load the
 `kotlinx.serialization` plugin and core library.
 
 ### Full serialization example
@@ -89,16 +89,16 @@ payloads for Kotlin classes by moving structural metadata into a compact header.
 * VarInts: Int/Long fields can be optimized using @VarUInt or @VarInt (ZigZag)
   annotations.
 * Full Graph Support: Handles nested objects, lists, maps, and polymorphism
-  recursively. While this is supported it will not produce as compact 
-  representations as flat structures that can pack all metadata into the same 
+  recursively. While this is supported it will not produce as compact
+  representations as flat structures that can pack all metadata into the same
   header.
 
 ### Field layout
 
 For a standard class, the encoding follows this structure:
 
 1. Bitmask Header: A variable length bitset containing bits for all booleans and
-   nullable indicators. A class with 10 booleans and 5 nullable fields uses 2 
+   nullable indicators. A class with 10 booleans and 5 nullable fields uses 2
    bytes for the header (the boolean variables are inlined to the header).
 2. Payload bytes: Fields are encoded in declaration order:
     * Primitives: Encoded densely (VarInt for Int/Long, fixed for others).
@@ -120,8 +120,8 @@ composing three layers:
 
 ```kotlin
 val format = EncodedFormat(
-    binaryFormat = ProtoBuf, 
-    checksum = Crc16, 
+    binaryFormat = ProtoBuf,
+    checksum = Crc16,
     codec = Base36
 )
 
@@ -160,5 +160,6 @@ val encrypted = cipher.doFinal(binary)
 // 3. Encode to Text
 val token = Base62.encode(encrypted)
 ```
+
 See [Examples](https://github.com/Eignex/kencode/blob/main/src/test/kotlin/com/eignex/kencode/Examples.kt)
 for a BouncyCastle demo.

src/main/kotlin/com/eignex/kencode/EncodedFormat.kt

@@ -62,7 +62,8 @@ open class EncodedFormat(
     override fun <T> encodeToString(
         serializer: SerializationStrategy<T>, value: T
     ): String {
-        val bytes = configuration.binaryFormat.encodeToByteArray(serializer, value)
+        val bytes =
+            configuration.binaryFormat.encodeToByteArray(serializer, value)
         val checked = if (configuration.checksum != null) {
             bytes + configuration.checksum.digest(bytes)
         } else bytes
@@ -81,7 +82,8 @@ open class EncodedFormat(
         val input = configuration.codec.decode(string)
         val bytes = if (configuration.checksum != null) {
             require(input.size >= configuration.checksum.size)
-            val bytes = input.sliceArray(0..<input.size - configuration.checksum.size)
+            val bytes =
+                input.sliceArray(0..<input.size - configuration.checksum.size)
             val actual =
                 input.sliceArray(input.size - configuration.checksum.size..<input.size)
             val expected = configuration.checksum.digest(bytes)
@@ -90,7 +92,10 @@ open class EncodedFormat(
             }
             bytes
         } else input
-        return configuration.binaryFormat.decodeFromByteArray(deserializer, bytes)
+        return configuration.binaryFormat.decodeFromByteArray(
+            deserializer,
+            bytes
+        )
     }
 }
 
@@ -138,7 +143,11 @@ fun EncodedFormat(
     }
     builder.builderAction()
 
-    val newConfig = EncodedConfiguration(builder.codec, builder.checksum, builder.binaryFormat)
+    val newConfig = EncodedConfiguration(
+        builder.codec,
+        builder.checksum,
+        builder.binaryFormat
+    )
 
     return EncodedFormat(newConfig)
 }

src/main/kotlin/com/eignex/kencode/PackedDecoder.kt

@@ -62,14 +62,21 @@ class PackedDecoder(
         } else {
             val allFlags: BooleanArray
             if (totalFlags > 64) {
-                val (byteCount, bytesRead) = PackedUtils.decodeVarInt(input, position)
+                val (byteCount, bytesRead) = PackedUtils.decodeVarInt(
+                    input,
+                    position
+                )
                 position += bytesRead
                 allFlags = PackedUtils.unpackFlags(input, position, byteCount)
                 position += byteCount
             } else {
-                val (flagsLong, bytesRead) = PackedUtils.decodeVarLong(input, position)
+                val (flagsLong, bytesRead) = PackedUtils.decodeVarLong(
+                    input,
+                    position
+                )
                 position += bytesRead
-                allFlags = PackedUtils.unpackFlagsFromLong(flagsLong, totalFlags)
+                allFlags =
+                    PackedUtils.unpackFlagsFromLong(flagsLong, totalFlags)
             }
 
             booleanValues = BooleanArray(booleanIndices.size) { i ->
@@ -122,15 +129,25 @@ class PackedDecoder(
     override fun decodeShort(): Short = readShortPos()
 
     override fun decodeInt(): Int {
-        return if (inStructure && !isCollection) decodeIntElement(currentDescriptor, currentIndex) else readIntPos()
+        return if (inStructure && !isCollection) decodeIntElement(
+            currentDescriptor,
+            currentIndex
+        ) else readIntPos()
     }
 
     override fun decodeLong(): Long {
-        return if (inStructure && !isCollection) decodeLongElement(currentDescriptor, currentIndex) else readLongPos()
+        return if (inStructure && !isCollection) decodeLongElement(
+            currentDescriptor,
+            currentIndex
+        ) else readLongPos()
     }
 
-    override fun decodeFloat(): Float = java.lang.Float.intBitsToFloat(readIntPos())
-    override fun decodeDouble(): Double = java.lang.Double.longBitsToDouble(readLongPos())
+    override fun decodeFloat(): Float =
+        java.lang.Float.intBitsToFloat(readIntPos())
+
+    override fun decodeDouble(): Double =
+        java.lang.Double.longBitsToDouble(readLongPos())
+
     override fun decodeChar(): Char = readUtf8Char()
     override fun decodeString(): String = readStringInline()
 
@@ -180,25 +197,38 @@ class PackedDecoder(
         for (i in booleanIndices.indices) if (booleanIndices[i] == index) return i
         return -1
     }
+
     private fun nullablePos(index: Int): Int {
         for (i in nullableIndices.indices) if (nullableIndices[i] == index) return i
         return -1
     }
 
-    override fun decodeBooleanElement(descriptor: SerialDescriptor, index: Int): Boolean {
+    override fun decodeBooleanElement(
+        descriptor: SerialDescriptor,
+        index: Int
+    ): Boolean {
         val pos = booleanPos(index)
         if (pos == -1) error("Element $index is not a boolean")
         return booleanValues[pos]
     }
 
-    override fun decodeByteElement(descriptor: SerialDescriptor, index: Int): Byte {
+    override fun decodeByteElement(
+        descriptor: SerialDescriptor,
+        index: Int
+    ): Byte {
         require(position < input.size)
         return input[position++]
     }
 
-    override fun decodeShortElement(descriptor: SerialDescriptor, index: Int): Short = readShortPos()
+    override fun decodeShortElement(
+        descriptor: SerialDescriptor,
+        index: Int
+    ): Short = readShortPos()
 
-    override fun decodeIntElement(descriptor: SerialDescriptor, index: Int): Int {
+    override fun decodeIntElement(
+        descriptor: SerialDescriptor,
+        index: Int
+    ): Int {
         val anns = descriptor.getElementAnnotations(index)
         val hasFixedInt = anns.hasFixedInt()
         val hasVarInt = anns.hasVarInt()
@@ -225,7 +255,10 @@ class PackedDecoder(
         }
     }
 
-    override fun decodeLongElement(descriptor: SerialDescriptor, index: Int): Long {
+    override fun decodeLongElement(
+        descriptor: SerialDescriptor,
+        index: Int
+    ): Long {
         val anns = descriptor.getElementAnnotations(index)
         val hasFixedInt = anns.hasFixedInt()
         val hasVarInt = anns.hasVarInt()
@@ -252,23 +285,42 @@ class PackedDecoder(
         }
     }
 
-    override fun decodeFloatElement(descriptor: SerialDescriptor, index: Int): Float =
+    override fun decodeFloatElement(
+        descriptor: SerialDescriptor,
+        index: Int
+    ): Float =
         java.lang.Float.intBitsToFloat(readIntPos())
 
-    override fun decodeDoubleElement(descriptor: SerialDescriptor, index: Int): Double =
+    override fun decodeDoubleElement(
+        descriptor: SerialDescriptor,
+        index: Int
+    ): Double =
         java.lang.Double.longBitsToDouble(readLongPos())
 
-    override fun decodeCharElement(descriptor: SerialDescriptor, index: Int): Char = readUtf8Char()
-    override fun decodeStringElement(descriptor: SerialDescriptor, index: Int): String = readStringInline()
+    override fun decodeCharElement(
+        descriptor: SerialDescriptor,
+        index: Int
+    ): Char = readUtf8Char()
+
+    override fun decodeStringElement(
+        descriptor: SerialDescriptor,
+        index: Int
+    ): String = readStringInline()
 
     @ExperimentalSerializationApi
-    override fun decodeInlineElement(descriptor: SerialDescriptor, index: Int): Decoder {
+    override fun decodeInlineElement(
+        descriptor: SerialDescriptor,
+        index: Int
+    ): Decoder {
         currentIndex = index
         return this
     }
 
     override fun <T> decodeSerializableElement(
-        descriptor: SerialDescriptor, index: Int, deserializer: DeserializationStrategy<T>, previousValue: T?
+        descriptor: SerialDescriptor,
+        index: Int,
+        deserializer: DeserializationStrategy<T>,
+        previousValue: T?
     ): T {
         currentIndex = index
 
@@ -291,30 +343,53 @@ class PackedDecoder(
 
     @ExperimentalSerializationApi
     override fun <T : Any> decodeNullableSerializableElement(
-        descriptor: SerialDescriptor, index: Int, deserializer: DeserializationStrategy<T?>, previousValue: T?
+        descriptor: SerialDescriptor,
+        index: Int,
+        deserializer: DeserializationStrategy<T?>,
+        previousValue: T?
     ): T? {
         if (isCollection) {
             val notNull = decodeNotNullMark()
             return if (notNull) {
-                decodeSerializableElement(descriptor, index, deserializer as DeserializationStrategy<T>, previousValue)
+                decodeSerializableElement(
+                    descriptor,
+                    index,
+                    deserializer as DeserializationStrategy<T>,
+                    previousValue
+                )
             } else {
                 decodeNull()
             }
         }
 
         val pos = nullablePos(index)
         if (pos == -1) {
-            return decodeSerializableElement(descriptor, index, deserializer as DeserializationStrategy<T>, previousValue)
+            return decodeSerializableElement(
+                descriptor,
+                index,
+                deserializer as DeserializationStrategy<T>,
+                previousValue
+            )
         }
 
         if (nullValues[pos]) return null
 
-        return decodeSerializableElement(descriptor, index, deserializer as DeserializationStrategy<T>, previousValue)
+        return decodeSerializableElement(
+            descriptor,
+            index,
+            deserializer as DeserializationStrategy<T>,
+            previousValue
+        )
     }
 
-    private fun readShortPos(): Short = PackedUtils.readShort(input, position).also { position += 2 }
-    private fun readIntPos(): Int = PackedUtils.readInt(input, position).also { position += 4 }
-    private fun readLongPos(): Long = PackedUtils.readLong(input, position).also { position += 8 }
+    private fun readShortPos(): Short =
+        PackedUtils.readShort(input, position).also { position += 2 }
+
+    private fun readIntPos(): Int =
+        PackedUtils.readInt(input, position).also { position += 4 }
+
+    private fun readLongPos(): Long =
+        PackedUtils.readLong(input, position).also { position += 8 }
 
     private fun readUtf8Char(): Char {
         require(position < input.size) { "Unexpected EOF while decoding UTF-8 char" }
@@ -327,6 +402,7 @@ class PackedDecoder(
                 require((b1 and 0b1100_0000) == 0b1000_0000) { "Invalid UTF-8 continuation byte" }
                 2 to (((b0 and 0x1F) shl 6) or (b1 and 0x3F))
             }
+
             (b0 and 0b1111_0000) == 0b1110_0000 -> {
                 require(position + 3 <= input.size)
                 val b1 = input[position + 1].toInt() and 0xFF
@@ -335,6 +411,7 @@ class PackedDecoder(
                 require((b2 and 0b1100_0000) == 0b1000_0000) { "Invalid UTF-8 continuation byte" }
                 3 to (((b0 and 0x0F) shl 12) or ((b1 and 0x3F) shl 6) or (b2 and 0x3F))
             }
+
             else -> throw IllegalArgumentException("Invalid UTF-8 start byte")
         }
         position += len