Relaxed field order preservation requirement for ObjectInput

[ghik]

See updated GenCodec docs and ObjectInput scaladocs for more details.

TLDR: instead of preserving field order, ObjectInput may alternatively override peekField and provide random field access by field name. This will allow formats using hashtable-based object representation (e.g. native JS representation) to be fully compatible with GenCodec - this currently only affects flat sealed hierarchy encoding and possible custom-written codecs.

[ddworak]

Nitpick: can we have if and else at the same level of indentation?

[ghik]

At a price of one more level of indentation, but whatever.

[ddworak]

2 unrelated questions about caseIndexByName:

1. Why can't we just use .indexOf(element, index)?
2. Does it make sense to use a more lookup-friendly data structure?

[ghik]

1. .indexOf(element, index) would put the underlying Array through implicit conversion to WrappedArray. I wanted to be as raw as possible.

2. I'm deliberately using Array and linear search here (and also in FieldValues) because case classes tend to have small number of fields and sealed hierarchies tend to have small number of case classes. Using a map would probably introduce more overhead. Also, note that if we wanted to improve on time complexity then the most natural thing would be a binary search, not using a map.

[ddworak]

Now that we have both .nextField and .peekField, we need an example more complex than a single field class and less automatically handled than a case class. I've seen a lot of people struggle with creating 2-field class codec and it's just getting harder.

More generally, should I peek or should I next? It appears to me that GenCodec won't exactly be completely Input/Output indepedent.

[ghik]

If you want to write a custom codec that creates an object with two-three fields then the way to go is to implement apply/unapply in companion object or use fromApplyUnapplyProvider. This is now very clearly recommended in the docs.

You should almost never need to implement an object codec manually. If you really need to do it then the backend-independent way of doing it would be:

class Klass(val int: Int, val str: String)
object Klass {
  private def getField(input: ObjectInput, name: String):
    input.peekField(name).orElse(input.nextField().opt).filter(_.fieldName == name)
      .getOrElse(throw new ReadFailure(s"expected field $name")

  implicit val codec: GenCodec[Klass] = GenCodec.createNullableObject(
    input => {
      val int = getField(input, "int").readInt()
      val str = getField(input, "str").readString()
      new Klass(int, str)
    },
    (klass, output) => {
      output.writeField("int").writeInt(klass.int)
      output.writeField("str").writeString(klass.str)
    }
  )
}

but really, this should be an absolute last resort.

[ghik]

Input and Output interfaces are generally optimized for ease of implementation and performance rather than ease of use.

[ddworak]

Nitpick: are there aaa fields as well? 😃

[ghik]

nooo

[ddworak]

These barbaric checks could be avoided if caseIndexByName would just return Opt[GenCodec[_: T]

[ghik]

Yeah but I can't similarly change caseIndexByValue because in writeObject I need to access both caseNames and caseDeps arrays. So I have to work with indices anyway.