Handle com.avsystem.commons.serialization.GenCodec.SizedCodec.size with IgnoreTransientDefaultMarker

Author: sebaciv

core/src/main/scala/com/avsystem/commons/serialization/GenCodec.scala

@@ -312,11 +312,13 @@ object GenCodec extends RecursiveAutoCodecs with TupleGenCodecs {
   }
 
   trait SizedCodec[T] extends GenCodec[T] {
-    def size(value: T): Int
+    def size(value: T): Int = size(value, Opt.Empty)
+
+    def size(value: T, output: Opt[SequentialOutput]): Int
 
     protected final def declareSizeFor(output: SequentialOutput, value: T): Unit =
       if (output.sizePolicy != SizePolicy.Ignored) {
-        output.declareSize(size(value))
+        output.declareSize(size(value, output.opt))
       }
   }
 
@@ -336,8 +338,8 @@ object GenCodec extends RecursiveAutoCodecs with TupleGenCodecs {
   object OOOFieldsObjectCodec {
     // this was introduced so that transparent wrapper cases are possible in flat sealed hierarchies
     final class Transformed[A, B](val wrapped: OOOFieldsObjectCodec[B], onWrite: A => B, onRead: B => A) extends OOOFieldsObjectCodec[A] {
-      def size(value: A): Int =
-        wrapped.size(onWrite(value))
+      def size(value: A, output: Opt[SequentialOutput]): Int =
+        wrapped.size(onWrite(value), output)
 
       def readObject(input: ObjectInput, outOfOrderFields: FieldValues): A =
         onRead(wrapped.readObject(input, outOfOrderFields))

core/src/main/scala/com/avsystem/commons/serialization/cbor/CborOptimizedCodecs.scala

@@ -87,7 +87,7 @@ class OOOFieldCborRawKeysCodec[T](stdObjectCodec: OOOFieldsObjectCodec[T], keyCo
     stdObjectCodec.writeFields(output, value)
   }
 
-  def size(value: T): Int = stdObjectCodec.size(value)
+  def size(value: T, output: Opt[SequentialOutput]): Int = stdObjectCodec.size(value, output)
   def nullable: Boolean = stdObjectCodec.nullable
 }
 

core/src/main/scala/com/avsystem/commons/serialization/macroCodecs.scala

@@ -12,7 +12,7 @@ class SingletonCodec[T <: Singleton](
 ) extends ErrorReportingCodec[T] with OOOFieldsObjectCodec[T] {
   final def nullable = true
   final def readObject(input: ObjectInput, outOfOrderFields: FieldValues): T = singletonValue
-  def size(value: T): Int = 0
+  def size(value: T, output: Opt[SequentialOutput]): Int = 0
   def writeFields(output: ObjectOutput, value: T): Unit = ()
 }
 
@@ -109,7 +109,7 @@ abstract class ProductCodec[T <: Product](
   nullable: Boolean,
   fieldNames: Array[String]
 ) extends ApplyUnapplyCodec[T](typeRepr, nullable, fieldNames) {
-  def size(value: T): Int = value.productArity
+  def size(value: T, output: Opt[SequentialOutput]): Int = value.productArity
 
   final def writeFields(output: ObjectOutput, value: T): Unit = {
     val size = value.productArity

core/src/test/scala/com/avsystem/commons/serialization/ObjectSizeTest.scala

@@ -34,4 +34,19 @@ class ObjectSizeTest extends AnyFunSuite {
     assert(CustomWrapper.codec.size(CustomWrapper()) == 0)
     assert(CustomWrapper.codec.size(CustomWrapper("fuu")) == 1)
   }
+
+  test("computing object size with custom output") {
+    val defaultIgnoringOutput = new SequentialOutput {
+      override def customEvent[T](marker: CustomEventMarker[T], event: T): Boolean =
+        marker match {
+          case IgnoreTransientDefaultMarker => true
+          case _ =>  super.customEvent(marker, event)
+        }
+      override def finish(): Unit = ()
+    }
+    assert(RecordWithDefaults.codec.size(RecordWithDefaults(), defaultIgnoringOutput.opt) == 3)
+    assert(RecordWithDefaults.codec.size(RecordWithDefaults("fuu"), defaultIgnoringOutput.opt) == 3)
+    assert(CustomRecordWithDefaults.codec.size(CustomRecordWithDefaults(), defaultIgnoringOutput.opt) == 2)
+    assert(CustomRecordWithDefaults.codec.size(CustomRecordWithDefaults("fuu"), defaultIgnoringOutput.opt) == 2)
+  }
 }

core/src/test/scala/com/avsystem/commons/serialization/cbor/CborInputOutputTest.scala

@@ -28,6 +28,18 @@ case class CustomKeysRecord(
 )
 object CustomKeysRecord extends HasCborCodec[CustomKeysRecord]
 
+case class CustomKeysRecordWithDefaults(
+  @transientDefault @cborKey(1) first: Int = 0,
+  @cborKey(true) second: Boolean,
+)
+object CustomKeysRecordWithDefaults extends HasCborCodec[CustomKeysRecordWithDefaults]
+
+case class CustomKeysRecordWithNoDefaults(
+  @cborKey(1) first: Int = 0,
+  @cborKey(true) second: Boolean,
+)
+object CustomKeysRecordWithNoDefaults extends HasCborCodec[CustomKeysRecordWithNoDefaults]
+
 @cborDiscriminator(0)
 sealed trait GenericSealedTrait[+T]
 object GenericSealedTrait extends HasPolyCborCodec[GenericSealedTrait] {
@@ -61,14 +73,22 @@ class CborInputOutputTest extends AnyFunSuite {
     keyCodec: CborKeyCodec = CborKeyCodec.Default
   )(implicit pos: Position): Unit =
     test(s"${pos.lineNumber}: $value") {
-      val baos = new ByteArrayOutputStream
-      val output = new CborOutput(new DataOutputStream(baos), keyCodec, SizePolicy.Optional)
-      GenCodec.write[T](output, value)
-      val bytes = baos.toByteArray
-      assert(Bytes(bytes).toString == binary)
-      assert(RawCbor(bytes).readAs[T](keyCodec) == value)
+      assertRoundtrip(value, binary, keyCodec)
     }
 
+  private def assertRoundtrip[T: GenCodec](
+    value: T,
+    binary: String,
+    keyCodec: CborKeyCodec = CborKeyCodec.Default
+  )(implicit pos: Position): Unit = {
+    val baos = new ByteArrayOutputStream
+    val output = new CborOutput(new DataOutputStream(baos), keyCodec, SizePolicy.Optional)
+    GenCodec.write[T](output, value)
+    val bytes = baos.toByteArray
+    assert(Bytes(bytes).toString == binary)
+    assert(RawCbor(bytes).readAs[T](keyCodec) == value)
+  }
+
   // binary representation from cbor.me
 
   roundtrip(null, "F6")
@@ -213,6 +233,22 @@ class CborInputOutputTest extends AnyFunSuite {
       """{"first":42,"second":true,"third":"foo","strMap":{"foo":1},"intMap":{"1":"foo"}}""")
   }
 
+  test("writing with IgnoreTransientDefaultMarker to CBOR output") {
+    val baos = new ByteArrayOutputStream
+    val output = CustomMarkersOutputWrapper(
+      new CborOutput(new DataOutputStream(baos), keyCodec, SizePolicy.Optional),
+      IgnoreTransientDefaultMarker,
+    )
+    val value = CustomKeysRecordWithDefaults(first = 0, second = true)
+    GenCodec.write(output, value)
+    val bytes = Bytes(baos.toByteArray)
+    assert(bytes.toString == "A20100F5F5")
+    assert(RawCbor(bytes.bytes).readAs[CustomKeysRecordWithDefaults](keyCodec) == value)
+
+    // should be the same as model with @transientDefault and serialization ignoring it
+    assertRoundtrip(CustomKeysRecordWithNoDefaults(first = 0, second = true), "A20100F5F5")
+  }
+
   test("chunked text string") {
     assert(CborInput.readRawCbor[String](RawCbor.fromHex("7F626162626162626162FF")) == "ababab")
   }

macros/src/main/scala/com/avsystem/commons/macros/serialization/GenCodecMacros.scala

@@ -313,8 +313,8 @@ class GenCodecMacros(ctx: blackbox.Context) extends CodecMacroCommons(ctx) with
       def sizeMethod: List[Tree] = if (useProductCodec) Nil else {
         val res =
           q"""
-            def size(value: $dtpe): $IntCls =
-              ${params.size} + ${generated.size} - $countTransientFields
+            def size(value: $dtpe, output: $OptCls[$SerializationPkg.SequentialOutput]): $IntCls =
+              ${params.size} + ${generated.size} - output.filter(_.customEvent($SerializationPkg.IgnoreTransientDefaultMarker, ())).mapOr($countTransientFields, _ => 0)
           """
         List(res)
       }