Merge pull request #633 from AVSystem/ignore-transient-default

Allow Output to ignore @transientDefault

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/IgnoreTransientDefaultMarker.scala

@@ -0,0 +1,15 @@
+package com.avsystem.commons
+package serialization
+
+/**
+  * Instructs [[GenCodec]] to <b>ignore</b> the [[transientDefault]] annotation when serializing a case class.
+  * This ensures that even if a field's value is the same as its default, it will be <b>included</b> in the serialized
+  * representation. Deserialization behavior remains <b>unchanged</b>. If a field is missing from the input, the default
+  * value will be used as usual.
+  *
+  * This marker can be helpful when using the same model class in multiple contexts with different serialization
+  * formats that have conflicting requirements for handling default values.
+  *
+  * @see [[CustomMarkersOutputWrapper]] for an easy way to add markers to existing [[Output]] implementations
+  */
+object IgnoreTransientDefaultMarker extends CustomEventMarker[Unit]

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/customMarkerWrappers.scala

@@ -0,0 +1,107 @@
+package com.avsystem.commons
+package serialization
+
+trait AcceptsAdditionalCustomMarkers extends AcceptsCustomEvents {
+
+  protected def markers: Set[CustomEventMarker[?]]
+
+  override def customEvent[T](marker: CustomEventMarker[T], event: T): Boolean =
+    markers(marker) || super.customEvent(marker, event)
+}
+
+/**
+  * [[Input]] implementation that adds additional markers [[CustomEventMarker]] to the provided [[Input]] instance
+  */
+final class CustomMarkersInputWrapper private(
+  override protected val wrapped: Input,
+  override protected val markers: Set[CustomEventMarker[?]],
+) extends InputWrapper with AcceptsAdditionalCustomMarkers {
+
+  override def readList(): ListInput =
+    new CustomMarkersInputWrapper.AdjustedListInput(super.readList(), markers)
+
+  override def readObject(): ObjectInput =
+    new CustomMarkersInputWrapper.AdjustedObjectInput(super.readObject(), markers)
+}
+object CustomMarkersInputWrapper {
+  def apply(input: Input, markers: CustomEventMarker[?]*): CustomMarkersInputWrapper =
+    CustomMarkersInputWrapper(input, markers.toSet)
+
+  def apply(input: Input, markers: Set[CustomEventMarker[?]]): CustomMarkersInputWrapper =
+    new CustomMarkersInputWrapper(input, markers)
+
+  private final class AdjustedListInput(
+    override protected val wrapped: ListInput,
+    override protected val markers: Set[CustomEventMarker[?]],
+  ) extends ListInputWrapper with AcceptsAdditionalCustomMarkers {
+    override def nextElement(): Input = new CustomMarkersInputWrapper(super.nextElement(), markers)
+  }
+
+  private final class AdjustedFieldInput(
+    override protected val wrapped: FieldInput,
+    override protected val markers: Set[CustomEventMarker[?]],
+  ) extends FieldInputWrapper with AcceptsAdditionalCustomMarkers {
+
+    override def readList(): ListInput = new AdjustedListInput(super.readList(), markers)
+    override def readObject(): ObjectInput = new AdjustedObjectInput(super.readObject(), markers)
+  }
+
+  private final class AdjustedObjectInput(
+    override protected val wrapped: ObjectInput,
+    override protected val markers: Set[CustomEventMarker[?]],
+  ) extends ObjectInputWrapper with AcceptsAdditionalCustomMarkers {
+
+    override def nextField(): FieldInput = new AdjustedFieldInput(super.nextField(), markers)
+    override def peekField(name: String): Opt[FieldInput] =
+      super.peekField(name).map(new AdjustedFieldInput(_, markers))
+  }
+}
+
+/**
+  * [[Output]] implementation that adds additional markers [[CustomEventMarker]] to the provided [[Output]] instance
+  */
+final class CustomMarkersOutputWrapper private(
+  override protected val wrapped: Output,
+  override protected val markers: Set[CustomEventMarker[?]],
+) extends OutputWrapper with AcceptsAdditionalCustomMarkers {
+
+  override def writeSimple(): SimpleOutput =
+    new CustomMarkersOutputWrapper.AdjustedSimpleOutput(super.writeSimple(), markers)
+
+  override def writeList(): ListOutput =
+    new CustomMarkersOutputWrapper.AdjustedListOutput(super.writeList(), markers)
+
+  override def writeObject(): ObjectOutput =
+    new CustomMarkersOutputWrapper.AdjustedObjectOutput(super.writeObject(), markers)
+}
+
+object CustomMarkersOutputWrapper {
+  def apply(output: Output, markers: CustomEventMarker[?]*): CustomMarkersOutputWrapper =
+    CustomMarkersOutputWrapper(output, markers.toSet)
+
+  def apply(output: Output, markers: Set[CustomEventMarker[?]]): CustomMarkersOutputWrapper =
+    new CustomMarkersOutputWrapper(output, markers)
+
+  private final class AdjustedSimpleOutput(
+    override protected val wrapped: SimpleOutput,
+    override protected val markers: Set[CustomEventMarker[?]],
+  ) extends SimpleOutputWrapper with AcceptsAdditionalCustomMarkers
+
+  private final class AdjustedListOutput(
+    override protected val wrapped: ListOutput,
+    override protected val markers: Set[CustomEventMarker[?]],
+  ) extends ListOutputWrapper with AcceptsAdditionalCustomMarkers {
+
+    override def writeElement(): Output =
+      new CustomMarkersOutputWrapper(super.writeElement(), markers)
+  }
+
+  private final class AdjustedObjectOutput(
+    override protected val wrapped: ObjectOutput,
+    override protected val markers: Set[CustomEventMarker[?]],
+  ) extends ObjectOutputWrapper with AcceptsAdditionalCustomMarkers {
+
+    override def writeField(key: String): Output =
+      new CustomMarkersOutputWrapper(super.writeField(key), markers)
+  }
+}

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/IgnoreTransientDefaultMarkerTest.scala

@@ -0,0 +1,75 @@
+package com.avsystem.commons
+package serialization
+
+import com.avsystem.commons.serialization.CodecTestData.HasDefaults
+
+object IgnoreTransientDefaultMarkerTest {
+  final case class NestedHasDefaults(
+    @transientDefault flag: Boolean = false,
+    obj: HasDefaults,
+    list: Seq[HasDefaults],
+    @transientDefault defaultObj: HasDefaults = HasDefaults(),
+  )
+  object NestedHasDefaults extends HasGenCodec[NestedHasDefaults]
+
+  final case class HasOptParam(
+    @transientDefault flag: Boolean = false,
+    @optionalParam str: Opt[String] = Opt.Empty,
+  )
+  object HasOptParam extends HasGenCodec[HasOptParam]
+}
+
+class IgnoreTransientDefaultMarkerTest extends AbstractCodecTest {
+  import IgnoreTransientDefaultMarkerTest.*
+
+  override type Raw = Any
+
+  def writeToOutput(write: Output => Unit): Any = {
+    var result: Any = null
+    write(CustomMarkersOutputWrapper(new SimpleValueOutput(v => result = v), IgnoreTransientDefaultMarker))
+    result
+  }
+
+  def createInput(raw: Any): Input =
+    CustomMarkersInputWrapper(new SimpleValueInput(raw), IgnoreTransientDefaultMarker)
+
+  test("write case class with default values") {
+    testWrite(HasDefaults(str = "lol"), Map("str" -> "lol", "int" -> 42))
+    testWrite(HasDefaults(43, "lol"), Map("int" -> 43, "str" -> "lol"))
+    testWrite(HasDefaults(str = null), Map("str" -> null, "int" -> 42))
+    testWrite(HasDefaults(str = "dafuq"), Map("str" -> "dafuq", "int" -> 42))
+  }
+
+  //noinspection RedundantDefaultArgument
+  test("read case class with default values") {
+    testRead(Map("str" -> "lol", "int" -> 42), HasDefaults(str = "lol", int = 42))
+    testRead(Map("str" -> "lol"), HasDefaults(str = "lol", int = 42))
+    testRead(Map("int" -> 43, "str" -> "lol"), HasDefaults(int = 43, str = "lol"))
+    testRead(Map("str" -> null, "int" -> 42), HasDefaults(str = null, int = 42))
+    testRead(Map("str" -> null), HasDefaults(str = null, int = 42))
+    testRead(Map(), HasDefaults(str = "dafuq", int = 42))
+  }
+
+  test("write case class with opt values") {
+    testWrite(HasOptParam(str = "lol".opt), Map("flag" -> false, "str" -> "lol"))
+    testWrite(HasOptParam(), Map("flag" -> false))
+  }
+
+  //noinspection RedundantDefaultArgument
+  test("write nested case class with default values") {
+    testWrite(
+      value = NestedHasDefaults(
+        flag = false,
+        obj = HasDefaults(str = "lol"),
+        list = Seq(HasDefaults(int = 43)),
+        defaultObj = HasDefaults(),
+      ),
+      expectedRepr = Map(
+        "flag" -> false,
+        "defaultObj" -> Map[String, Any]("str" -> "kek", "int" -> 42),
+        "obj" -> Map[String, Any]("str" -> "lol", "int" -> 42),
+        "list" -> List(Map[String, Any]("str" -> "kek", "int" -> 43)),
+      ),
+    )
+  }
+}

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

@@ -3,35 +3,77 @@ package serialization
 
 import org.scalatest.funsuite.AnyFunSuite
 
-case class RecordWithDefaults(
+final case class RecordWithDefaults(
   @transientDefault a: String = "",
   b: Int = 42
 ) {
   @generated def c: String = s"$a-$b"
 }
 object RecordWithDefaults extends HasApplyUnapplyCodec[RecordWithDefaults]
 
-class CustomRecordWithDefaults(val a: String, val b: Int)
+final class CustomRecordWithDefaults(val a: String, val b: Int)
 object CustomRecordWithDefaults extends HasApplyUnapplyCodec[CustomRecordWithDefaults] {
   def apply(@transientDefault a: String = "", b: Int = 42): CustomRecordWithDefaults =
     new CustomRecordWithDefaults(a, b)
   def unapply(crwd: CustomRecordWithDefaults): Opt[(String, Int)] =
     Opt((crwd.a, crwd.b))
 }
 
-class CustomWrapper(val a: String)
+final class CustomWrapper(val a: String)
 object CustomWrapper extends HasApplyUnapplyCodec[CustomWrapper] {
   def apply(@transientDefault a: String = ""): CustomWrapper = new CustomWrapper(a)
   def unapply(cw: CustomWrapper): Opt[String] = Opt(cw.a)
 }
 
+final case class RecordWithOpts(
+  @optionalParam abc: Opt[String] = Opt.Empty,
+  @transientDefault flag: Opt[Boolean] = Opt.Empty,
+  b: Int = 42,
+)
+object RecordWithOpts extends HasApplyUnapplyCodec[RecordWithOpts]
+
+final case class SingleFieldRecordWithOpts(@optionalParam abc: Opt[String] = Opt.Empty)
+object SingleFieldRecordWithOpts extends HasApplyUnapplyCodec[SingleFieldRecordWithOpts]
+
+final case class SingleFieldRecordWithTD(@transientDefault abc: String = "abc")
+object SingleFieldRecordWithTD extends HasApplyUnapplyCodec[SingleFieldRecordWithTD]
+
 class ObjectSizeTest extends AnyFunSuite {
   test("computing object size") {
     assert(RecordWithDefaults.codec.size(RecordWithDefaults()) == 2)
     assert(RecordWithDefaults.codec.size(RecordWithDefaults("fuu")) == 3)
+    assert(RecordWithOpts.codec.size(RecordWithOpts("abc".opt)) == 2)
+    assert(RecordWithOpts.codec.size(RecordWithOpts("abc".opt, true.opt)) == 3)
+    assert(RecordWithOpts.codec.size(RecordWithOpts()) == 1)
+    assert(SingleFieldRecordWithOpts.codec.size(SingleFieldRecordWithOpts()) == 0)
+    assert(SingleFieldRecordWithOpts.codec.size(SingleFieldRecordWithOpts("abc".opt)) == 1)
+    assert(SingleFieldRecordWithTD.codec.size(SingleFieldRecordWithTD()) == 0)
+    assert(SingleFieldRecordWithTD.codec.size(SingleFieldRecordWithTD("haha")) == 1)
     assert(CustomRecordWithDefaults.codec.size(CustomRecordWithDefaults()) == 1)
     assert(CustomRecordWithDefaults.codec.size(CustomRecordWithDefaults("fuu")) == 2)
     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(RecordWithOpts.codec.size(RecordWithOpts("abc".opt), defaultIgnoringOutput.opt) == 3)
+    assert(RecordWithOpts.codec.size(RecordWithOpts("abc".opt, true.opt), defaultIgnoringOutput.opt) == 3)
+    assert(RecordWithOpts.codec.size(RecordWithOpts(), defaultIgnoringOutput.opt) == 2)
+    assert(SingleFieldRecordWithOpts.codec.size(SingleFieldRecordWithOpts(), defaultIgnoringOutput.opt) == 0) // @optionalParam field should NOT be counted
+    assert(SingleFieldRecordWithOpts.codec.size(SingleFieldRecordWithOpts("abc".opt), defaultIgnoringOutput.opt) == 1)
+    assert(SingleFieldRecordWithTD.codec.size(SingleFieldRecordWithTD(), defaultIgnoringOutput.opt) == 1) // @transientDefault field should be counted
+    assert(SingleFieldRecordWithTD.codec.size(SingleFieldRecordWithTD("haha"), defaultIgnoringOutput.opt) == 1)
+    assert(CustomRecordWithDefaults.codec.size(CustomRecordWithDefaults(), defaultIgnoringOutput.opt) == 2)
+    assert(CustomRecordWithDefaults.codec.size(CustomRecordWithDefaults("fuu"), defaultIgnoringOutput.opt) == 2)
+  }
 }