Reading numbers (and other types) as string

Currently parsing strings to numbers can be enabled by isStringified or @stringified, but the possibility to enable parsing any value as a String (be it numbers or booleans, etc) could be useful. One case is when parsing json documents from MongoDB where there is no schema on write and users add ids as strings, doubles, longs (for the same field, e.g. id) only to be truncated (if needed) to integers in the end.

To the extent of my knowledge in jsoniter-scala there is currently no possibility to do this without writing custom codec and it takes a lot of coding on user’s side.

[plokhotnyuk]

Lets for simplicity assume that 64 bits will be enough for internal binary representation of ID.

Than the definition of the ID type and a codec for it can be like in the code snippet below:

import com.github.plokhotnyuk.jsoniter_scala.macros._
import com.github.plokhotnyuk.jsoniter_scala.core._

case class ID(bits: Long) {
  override def hashCode: Int = (bits ^ (bits >> 32)).toInt

  override def equals(obj: Any): _root_.scala.Boolean = obj match {
    case that: ID => bits == that.bits
    case _ => false
  }

  override def toString: String = bits.toString
}

object ID {
  implicit val codec: JsonValueCodec[ID] = new JsonValueCodec[ID] {
    override def decodeValue(in: JsonReader, default: ID): ID = new ID({
      in.nextToken() match {
        case '{' =>
          val n = in.readKeyAsCharBuf()
          var l = 0L
          if (!in.isCharBufEqualsTo(n, "$numberLong") || {
            l = in.readStringAsLong()
            !in.isNextToken('}')
          }) in.decodeError("illegal ID value")
          l
        case '"' =>
          in.rollbackToken()
          val d = in.readStringAsDouble()
          if (d != d.toLong) in.decodeError("illegal ID value")
          d.toLong
        case _ =>
          in.rollbackToken()
          val d = in.readDouble()
          if (d != d.toLong) in.decodeError("illegal ID value")
          d.toLong
      }
    })

    override def encodeValue(x: ID, out: JsonWriter): Unit = {
      val bits = x.bits
      if (bits != bits.toDouble.toLong) {
        out.writeObjectStart()
        out.writeNonEscapedAsciiKey("$numberLong")
        out.writeValAsString(bits)
        out.writeObjectEnd()
      } else out.writeVal(bits)
    }

    override val nullValue: ID = new ID(0L)
  }
}

case class User(id: ID, name: String)

implicit val codec: JsonValueCodec[User] = JsonCodecMaker.make(CodecMakerConfig)

val jsonSamples = Seq(
  """{"id":{"$numberLong": "123456789" }, "name": "Dave"}""",
  """{"id":"123456789", "name": "Dave"}""",
  """{"id":123456789, "name": "Dave"}""",
  """{"id":123456789.0, "name": "Dave"}"""
).map(_.getBytes("UTF-8"))

jsonSamples.foreach(json => println(readFromArray[User](json)))

println(new String(writeToArray(User(id = ID(1234567890123456789L), name = "John")), "UTF-8"))
println(new String(writeToArray(User(id = ID(123456789L), name = "Dave")), "UTF-8"))

It should print the following output:

User(123456789,Dave)
User(123456789,Dave)
User(123456789,Dave)
User(123456789,Dave)
{"id":{"$numberLong":"1234567890123456789"},"name":"John"}
{"id":123456789,"name":"Dave"}

[hubert-skowronek]

Do you have some example of implementation of such custom codec?

Any other options for representation of IDs in Mongo is rather everything - Longs, Strings, UUIDs, compound types, etc (but in my case id is a number but can be persisted as int/long/double/stringified number…)

You are right, the following representations are equal in my case.