tree encoding half-done

Author: JesusMcCloud

formats/cbor/commonMain/src/kotlinx/serialization/cbor/Cbor.kt

@@ -88,8 +88,19 @@ public sealed class Cbor(
         val reader = CborReader(this, CborParser(stream, configuration.verifyObjectTags))
         return reader.decodeSerializableValue(deserializer)
     }
+
+
+    public fun  <T> encodeToCbor(serializer: SerializationStrategy<T>, value: T): CborElement {
+        val writer = StructuredCborWriter(this)
+        writer.encodeSerializableValue(serializer, value)
+      return  writer.finalize()
+    }
 }
 
+@ExperimentalSerializationApi
+public inline fun <reified T> Cbor.encodeToCbor(value: T): CborElement =
+    encodeToCbor(serializersModule.serializer(), value)
+
 @OptIn(ExperimentalSerializationApi::class)
 private class CborImpl(
     configuration: CborConfiguration,

formats/cbor/commonMain/src/kotlinx/serialization/cbor/CborElement.kt

@@ -28,8 +28,19 @@ public sealed class CborElement(
      * See [RFC 8949 3.4. Tagging of Items](https://datatracker.ietf.org/doc/html/rfc8949#name-tagging-of-items).
      */
     @OptIn(ExperimentalUnsignedTypes::class)
-    public val tags: ULongArray = ulongArrayOf()
-)
+    tags: ULongArray = ulongArrayOf()
+
+) {
+    /**
+     * CBOR tags associated with this element.
+     * Tags are optional semantic tagging of other major types (major type 6).
+     * See [RFC 8949 3.4. Tagging of Items](https://datatracker.ietf.org/doc/html/rfc8949#name-tagging-of-items).
+     */
+    @OptIn(ExperimentalUnsignedTypes::class)
+    public var tags: ULongArray = tags
+        internal set
+
+}
 
 /**
  * Class representing CBOR primitive value.
@@ -73,6 +84,11 @@ public class CborPositiveInt(
     override fun hashCode(): Int = value.hashCode() * 31 + tags.contentHashCode()
 }
 
+public fun CborInt(
+    value: Long,
+    tags: ULongArray = ulongArrayOf()
+): CborPrimitive = if (value >= 0) CborPositiveInt(value.toULong(), tags) else CborNegativeInt(value, tags)
+
 /**
  * Class representing CBOR floating point value (major type 7).
  */
@@ -147,7 +163,7 @@ public class CborByteString(
  * Class representing CBOR `null` value
  */
 @Serializable(with = CborNullSerializer::class)
-public class CborNull(tags: ULongArray=ulongArrayOf()) : CborPrimitive(tags) {
+public class CborNull(tags: ULongArray = ulongArrayOf()) : CborPrimitive(tags) {
     // Note: CborNull is an object, so it cannot have constructor parameters for tags
     // If tags are needed for null values, this would need to be changed to a class
     override fun equals(other: Any?): Boolean {
@@ -172,12 +188,12 @@ public class CborMap(
     private val content: Map<CborElement, CborElement>,
     tags: ULongArray = ulongArrayOf()
 ) : CborElement(tags), Map<CborElement, CborElement> by content {
-    
+
     public override fun equals(other: Any?): Boolean =
         other is CborMap && other.content == content && other.tags.contentEquals(tags)
 
     public override fun hashCode(): Int = content.hashCode() * 31 + tags.contentHashCode()
-    
+
     public override fun toString(): String = content.toString()
 }
 
@@ -192,11 +208,11 @@ public class CborList(
     private val content: List<CborElement>,
     tags: ULongArray = ulongArrayOf()
 ) : CborElement(tags), List<CborElement> by content {
-    
+
     public override fun equals(other: Any?): Boolean =
         other is CborList && other.content == content && other.tags.contentEquals(tags)
 
     public override fun hashCode(): Int = content.hashCode() * 31 + tags.contentHashCode()
-    
+
     public override fun toString(): String = content.toString()
 }

formats/cbor/commonMain/src/kotlinx/serialization/cbor/internal/CborElementSerializers.kt

@@ -189,7 +189,7 @@ public object CborBooleanSerializer : KSerializer<CborBoolean> {
 
 /**
  * Serializer object providing [SerializationStrategy] and [DeserializationStrategy] for [CborByteString].
- * It can only be used by with [Cbor] format an its input ([CborDecoder] and [CborEncoder]).
+ * It can only be used by with [Cbor] format and its input ([CborDecoder] and [CborEncoder]).
  */
 public object CborByteStringSerializer : KSerializer<CborByteString> {
     override val descriptor: SerialDescriptor =
@@ -211,7 +211,7 @@ public object CborByteStringSerializer : KSerializer<CborByteString> {
 
 /**
  * Serializer object providing [SerializationStrategy] and [DeserializationStrategy] for [CborMap].
- * It can only be used by with [Cbor] format an its input ([CborDecoder] and [CborEncoder]).
+ * It can only be used by with [Cbor] format and its input ([CborDecoder] and [CborEncoder]).
  */
 public object CborMapSerializer : KSerializer<CborMap> {
     private object CborMapDescriptor :

formats/cbor/commonMain/src/kotlinx/serialization/cbor/internal/Encoder.kt

@@ -26,10 +26,9 @@ private fun Stack.peek() = last()
 // Split implementation to optimize base case
 internal sealed class CborWriter(
     override val cbor: Cbor,
-    protected val output: ByteArrayOutput,
 ) : AbstractEncoder(), CborEncoder {
 
-    internal fun encodeByteString(byteArray: ByteArray) {
+    internal open fun encodeByteString(byteArray: ByteArray) {
         getDestination().encodeByteString(byteArray)
     }
 
@@ -155,8 +154,8 @@ internal sealed class CborWriter(
 
 
 // optimized indefinite length encoder
-internal class IndefiniteLengthCborWriter(cbor: Cbor, output: ByteArrayOutput) : CborWriter(
-    cbor, output
+internal class IndefiniteLengthCborWriter(cbor: Cbor, private val output: ByteArrayOutput) : CborWriter(
+    cbor
 ) {
 
     override fun beginStructure(descriptor: SerialDescriptor): CompositeEncoder {
@@ -187,8 +186,162 @@ internal class IndefiniteLengthCborWriter(cbor: Cbor, output: ByteArrayOutput) :
 
 }
 
+// optimized indefinite length encoder
+internal class StructuredCborWriter(cbor: Cbor) : CborWriter(
+    cbor
+) {
+
+    sealed class CborContainer(tags: ULongArray, elements: MutableList<CborElement>)  {
+        var elements = elements
+            private set
+
+        var tags = tags
+            internal set
+
+
+        fun add(element: CborElement) = elements.add(element)
+        class Map(tags: ULongArray, elements: MutableList<CborElement> = mutableListOf()) :
+            CborContainer(tags, elements) {
+        }
+
+        class List(tags: ULongArray, elements: MutableList<CborElement> = mutableListOf()) :
+            CborContainer(tags, elements) {
+        }
+
+        class Primitive(tags: ULongArray) : CborContainer(tags, elements = mutableListOf()) {
+
+        }
+
+        fun finalize() = when (this) {
+            is List -> CborList(content = elements, tags = tags)
+            is Map -> CborMap(
+                content = if (elements.isNotEmpty()) IntRange(0, elements.size / 2 - 1).associate {
+                    elements[it * 2] to elements[it * 2 + 1]
+                } else mapOf(),
+                tags = tags
+            )
+
+            is Primitive -> elements.first().also { it.tags = tags }
+
+        }
+    }
+
+    private val stack = ArrayDeque<CborContainer>()
+    private var currentElement: CborContainer? = null
+
+    fun finalize() =currentElement!!.finalize()
+
+    override fun beginStructure(descriptor: SerialDescriptor): CompositeEncoder {
+        val tags = descriptor.getObjectTags() ?: ulongArrayOf()
+        val element = if (descriptor.hasArrayTag()) {
+            CborContainer.List(tags)
+        } else {
+            when (descriptor.kind) {
+                StructureKind.LIST, is PolymorphicKind -> CborContainer.List(tags)
+                is StructureKind.MAP -> CborContainer.Map(tags)
+                else -> CborContainer.Map(tags)
+            }
+        }
+        currentElement?.let { stack.add(it) }
+        currentElement = element
+        return this
+    }
+
+    override fun endStructure(descriptor: SerialDescriptor) {
+        val finalized = currentElement!!.finalize()
+        if (stack.isNotEmpty()) {
+            currentElement = stack.removeLast()
+            currentElement!!.add(finalized)
+        }
+    }
+
+    override fun getDestination() = TODO()
+
+
+    override fun incrementChildren() {/*NOOP*/
+    }
+
+
+    override fun encodeElement(descriptor: SerialDescriptor, index: Int): Boolean {
+        //TODO check if cborelement and be done
+        val name = descriptor.getElementName(index)
+        if (!descriptor.hasArrayTag()) {
+            val keyTags = descriptor.getKeyTags(index)
+
+            if ((descriptor.kind !is StructureKind.LIST) && (descriptor.kind !is StructureKind.MAP) && (descriptor.kind !is PolymorphicKind)) {
+                //indices are put into the name field. we don't want to write those, as it would result in double writes
+                val cborLabel = descriptor.getCborLabel(index)
+                if (cbor.configuration.preferCborLabelsOverNames && cborLabel != null) {
+                    currentElement!!.add(
+                        CborInt(cborLabel, keyTags ?: ulongArrayOf())
+                    )
+                } else {
+                    currentElement!!.add(CborString(name, keyTags ?: ulongArrayOf()))
+                }
+            }
+        }
+
+        if (cbor.configuration.encodeValueTags) {
+            descriptor.getValueTags(index)?.let { valueTags ->
+                currentElement!!.tags += valueTags
+            }
+        }
+        return true
+    }
+
+
+    override fun encodeBoolean(value: Boolean) {
+        currentElement!!.add(CborBoolean(value))
+    }
+
+    override fun encodeByte(value: Byte) {
+        currentElement!!.add(CborInt(value.toLong()))
+    }
+
+    override fun encodeChar(value: Char) {
+        currentElement!!.add(CborInt(value.code.toLong()))
+    }
+
+    override fun encodeDouble(value: Double) {
+        currentElement!!.add(CborDouble(value))
+    }
+
+    override fun encodeFloat(value: Float) {
+        currentElement!!.add(CborDouble(value.toDouble()))
+    }
+
+    override fun encodeInt(value: Int) {
+        currentElement!!.add(CborInt(value.toLong()))
+    }
+
+    override fun encodeLong(value: Long) {
+        currentElement!!.add(CborInt(value))
+    }
+
+    override fun encodeShort(value: Short) {
+        currentElement!!.add(CborInt(value.toLong()))
+    }
+
+    override fun encodeString(value: String) {
+        currentElement!!.add(CborString(value))
+    }
+
+    override fun encodeByteString(byteArray: ByteArray) {
+        currentElement!!.add(CborByteString(byteArray))
+    }
+
+    override fun encodeNull() {
+        currentElement!!.add(CborNull())
+    }
+
+    override fun encodeEnum(enumDescriptor: SerialDescriptor, index: Int) {
+        currentElement!!.add(CborString(enumDescriptor.getElementName(index)))
+    }
+
+}
+
 //optimized definite length encoder
-internal class DefiniteLengthCborWriter(cbor: Cbor, output: ByteArrayOutput) : CborWriter(cbor, output) {
+internal class DefiniteLengthCborWriter(cbor: Cbor, output: ByteArrayOutput) : CborWriter(cbor) {
 
     private val structureStack = Stack(Data(output, -1))
     override fun getDestination(): ByteArrayOutput =

formats/cbor/commonTest/src/kotlinx/serialization/cbor/CborWriterTest.kt

@@ -5,6 +5,7 @@
 package kotlinx.serialization.cbor
 
 import kotlinx.serialization.*
+import kotlinx.serialization.cbor.CborSkipTagAndEmptyTest.DataClass
 import kotlin.test.*
 
 
@@ -31,6 +32,8 @@ class CbrWriterTest {
             "bf637374726d48656c6c6f2c20776f726c64216169182a686e756c6c61626c65f6646c6973749f61616162ff636d6170bf01f502f4ff65696e6e6572bf6161636c6f6cff6a696e6e6572734c6973749fbf6161636b656bffff6a62797465537472696e6742cafe696279746541727261799f383521ffff",
             Cbor.encodeToHexString(TypesUmbrella.serializer(), test)
         )
+       val struct= Cbor.encodeToCbor(test)
+        println(struct)
     }
 
     @Test