Refactor reader API: rename requiredKeyError to requiredFieldError, add overloaded requiredFieldError with already resolved name, replace scanToKey by skipToKey

Author: plokhotnyuk

core/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala

@@ -55,7 +55,14 @@ final class JsonReader private[jsoniter_scala](
     private[this] var in: InputStream = null,
     private[this] var totalRead: Long = 0,
     private[this] var config: ReaderConfig = null) {
-  def requiredKeyError(reqFields: Array[String], reqBits: Array[Int]): Nothing = {
+  def requiredFieldError(reqField: String): Nothing = {
+    var i = appendString("missing required field \"", 0)
+    i = appendString(reqField, i)
+    i = appendChar('"', i)
+    decodeError(i, head - 1, null)
+  }
+
+  def requiredFieldError(reqFields: Array[String], reqBits: Array[Int]): Nothing = {
     val len = Math.min(reqFields.length, reqBits.length << 5)
     var i = 0
     var j = 0
@@ -103,10 +110,9 @@ final class JsonReader private[jsoniter_scala](
   def setMark(): Unit = mark = head
 
   @tailrec
-  def scanToKey(s: String): Unit = if (!isCharBufEqualsTo(readKeyAsCharBuf(), s)) {
+  def skipToKey(key: String): Boolean = isCharBufEqualsTo(readKeyAsCharBuf(), key) || {
     skip()
-    if (isNextToken(',', head)) scanToKey(s)
-    else reqFieldError(s)
+    isNextToken(',', head) && skipToKey(key)
   }
 
   def rollbackToMark(): Unit = {
@@ -639,13 +645,6 @@ final class JsonReader private[jsoniter_scala](
     decodeError(i, pos, null)
   }
 
-  private def reqFieldError(s: String): Nothing = {
-    var i = appendString("missing required field \"", 0)
-    i = appendString(s, i)
-    i = appendChar('"', i)
-    decodeError(i, head - 1, null)
-  }
-
   private def decodeError(msg: String, pos: Int, cause: Throwable = null): Nothing =
     decodeError(appendString(msg, 0), pos, cause)
 

core/src/test/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReaderSpec.scala

@@ -1951,34 +1951,34 @@ class JsonReaderSpec extends WordSpec with Matchers with PropertyChecks {
         .getMessage.contains("expected preceding call of 'setMark()'"))
     }
   }
-  "JsonReader.scanToKey" should {
-    "find key-value pair by provided key and set current position of parsing to its value" in {
+  "JsonReader.skipToKey" should {
+    "return true in case of key is found and set current position of parsing to its value" in {
       val jsonReader = reader("""{"key1":1,"key2":2}""".getBytes)
       jsonReader.isNextToken('{') // enter to JSON object
-      jsonReader.scanToKey("key2")
+      jsonReader.skipToKey("key2") shouldBe true
       jsonReader.readInt() shouldBe 2
     }
-    "throw parsing exception in case of key-value pair of provided key cannot be found" in {
+    "return false in case of key cannot be found and set current positing to the closing of object" in {
       val jsonReader = reader("""{"key1":1}""".getBytes)
       jsonReader.isNextToken('{') // enter to JSON object
-      assert(intercept[JsonParseException](jsonReader.scanToKey("key2"))
-        .getMessage.contains("missing required field \"key2\", offset: 0x00000009"))
+      jsonReader.skipToKey("key2")
+      jsonReader.isCurrentToken('}') shouldBe true
     }
   }
-  "JsonReader.requiredKeyError" should {
+  "JsonReader.requiredFieldError" should {
     val jsonReader = reader("{}".getBytes)
     jsonReader.nextToken()
     "throw parsing exception with list of missing required fields that specified by bits" in {
       def check(bits: Int, error: String): Unit =
-        assert(intercept[JsonParseException](jsonReader.requiredKeyError(Array("name", "device"), Array(bits)))
+        assert(intercept[JsonParseException](jsonReader.requiredFieldError(Array("name", "device"), Array(bits)))
           .getMessage.contains(error))
 
       check(3, "missing required field(s) \"name\", \"device\", offset: 0x00000000")
       check(2, "missing required field(s) \"device\", offset: 0x00000000")
       check(1, "missing required field(s) \"name\", offset: 0x00000000")
     }
     "throw illegal argument exception in case of missing required fields cannot be selected" in {
-      assert(intercept[IllegalArgumentException](jsonReader.requiredKeyError(Array("name", "device"), Array(0)))
+      assert(intercept[IllegalArgumentException](jsonReader.requiredFieldError(Array("name", "device"), Array(0)))
         .getMessage.contains("missing required field(s) cannot be reported for arguments: " +
           "reqFields = Array(name, device), reqBits = Array(0)"))
     }

core/src/test/scala/com/github/plokhotnyuk/jsoniter_scala/core/UserAPI.scala

@@ -50,7 +50,7 @@ object UserAPI {
           if (!in.isCurrentToken('}')) in.objectEndOrCommaError()
         }
         if (req0 == 0) new Device(id = _id, model = _model)
-        else in.requiredKeyError(r1, Array(req0))
+        else in.requiredFieldError(r1, Array(req0))
       } else in.readNullOrTokenError(default, '{')
 
     private def d1(in: JsonReader, default: Seq[Device]): Seq[Device] = 
@@ -90,7 +90,7 @@ object UserAPI {
           if (in.isCurrentToken('}').`unary_!`) in.objectEndOrCommaError()
         }
         if (req0 == 0) new User(name = _name, devices = _devices)
-        else in.requiredKeyError(r0, Array(req0))
+        else in.requiredFieldError(r0, Array(req0))
       } else in.readNullOrTokenError(default, '{')
 
     private def e2(x: Device, out: JsonWriter): Unit = {

macros/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/macros/JsonCodecMaker.scala

@@ -647,7 +647,7 @@ object JsonCodecMaker {
                 required.map(r => getMappedName(annotations, r))
               }
               q"""if ($checkReqVars) $construct
-                  else in.requiredKeyError($reqFieldNames, Array(..$reqVarNames))"""
+                  else in.requiredFieldError($reqFieldNames, Array(..$reqVarNames))"""
             }
           val defaults = getDefaults(tpe)
           val readVars = members.map { m =>
@@ -692,8 +692,9 @@ object JsonCodecMaker {
           }
 
           val leafClasses = adtLeafClasses(tpe).toSeq
-          checkDiscriminatorValueCollisions(codecConfig.discriminatorFieldName, leafClasses.map(discriminatorValue))
-          val discriminatorValueError = q"in.discriminatorValueError(${codecConfig.discriminatorFieldName})"
+          val discrName = codecConfig.discriminatorFieldName
+          checkDiscriminatorValueCollisions(discrName, leafClasses.map(discriminatorValue))
+          val discriminatorValueError = q"in.discriminatorValueError($discrName)"
           val readSubclasses = groupByOrdered(leafClasses)(hashCode).map { case (hashCode, subTpes) =>
             val checkNameAndReadValue = subTpes.foldRight(discriminatorValueError) { case (subTpe, acc) =>
               q"""if (in.isCharBufEqualsTo(l, ${discriminatorValue(subTpe)})) {
@@ -705,12 +706,13 @@ object JsonCodecMaker {
           }(breakOut)
           q"""in.setMark()
               if (in.isNextToken('{')) {
-                in.scanToKey(${codecConfig.discriminatorFieldName})
-                val l = in.readStringAsCharBuf()
-                (in.charBufToHashCode(l): @switch) match {
-                  case ..$readSubclasses
-                  case _ => $discriminatorValueError
-                }
+                if (in.skipToKey($discrName)) {
+                  val l = in.readStringAsCharBuf()
+                  (in.charBufToHashCode(l): @switch) match {
+                    case ..$readSubclasses
+                    case _ => $discriminatorValueError
+                  }
+                } else in.requiredFieldError($discrName)
               } else in.readNullOrTokenError(default, '{')"""
         } else cannotFindCodecError(tpe)
       }