plokhotnyuk/jsoniter-scala

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

object Example01 {
  sealed trait MapValue
  case class StringMapValue(value: String) extends MapValue
  case class BooleanMapValue(value: Boolean) extends MapValue
  case class DoubleMapValue(value: Double) extends MapValue
  case class IntMapValue(value: Int) extends MapValue
  case object NullMapValue extends MapValue

  case class Data(id: String, fields: Map[String, MapValue], num: Int)

  implicit val mapValueCodec: JsonValueCodec[MapValue] = new JsonValueCodec[MapValue] {
    override def decodeValue(in: JsonReader, default: MapValue): MapValue = {
      val b = in.nextToken()
      if (b == '"') {
        in.rollbackToken()
        StringMapValue(in.readString(null))
      } else if (b >= '0' && b <= '9' || b == '-') {
        in.rollbackToken()
        val d = in.readDouble()
        val i = d.toInt
        if (i.toDouble == d) IntMapValue(i)
        else DoubleMapValue(d)
      } else if (b == 't' || b == 'f') {
        in.rollbackToken()
        BooleanMapValue(in.readBoolean())
      } else if (b == 'n') {
        in.readNullOrError(default, "expected `null` value")
        NullMapValue
      } else in.decodeError("expected JSON value")
    }

    override def encodeValue(x: MapValue, out: JsonWriter): Unit = x match {
      case NullMapValue => out.writeNull()
      case StringMapValue(x) => out.writeVal(x)
      case BooleanMapValue(x) => out.writeVal(x)
      case IntMapValue(x) => out.writeVal(x)
      case DoubleMapValue(x) => out.writeVal(x)
    }

    override def nullValue: MapValue = NullMapValue
  }

  implicit val codec: JsonValueCodec[Data] = JsonCodecMaker.make

  def main(args: Array[String]): Unit = {
    val data = readFromArray[Data]("""{
                               |  "id" : "FOO",
                               |  "num": 456,
                               |  "fields" : {
                               |    "time" : 123,
                               |    "bar" : "baz",
                               |    "bool" : true,
                               |    "double" : 123.456890123,
                               |    "null" : null
                               |  }
                               |}""".stripMargin.getBytes("UTF-8"))
    val json = writeToArray(Data(id = "BAR", num = 123,
      fields = Map[String, MapValue]("time" -> IntMapValue(123), "bar" -> StringMapValue("baz"))))

    println(data)
    println(new String(json, "UTF-8"))
  }
}