Reduce allocations in outputc collectors. Cache hashcode to avoid deep recurcive calculation

Author: OptimumCode

src/commonMain/kotlin/io/github/optimumcode/json/pointer/JsonPointer.kt

@@ -66,19 +66,29 @@ public sealed class JsonPointer(
     if (this !is SegmentPointer) {
       return last
     }
-    var parent: PointerParent? = null
-    var node: JsonPointer = this
-    while (node is SegmentPointer) {
-      parent =
-        PointerParent(
-          parent,
-          node.propertyName,
-          node.index,
+    return insertLastDeepCopy(this, last)
+  }
+
+  // there might be an issue with stack in case this function is called deep on the stack
+  private fun insertLastDeepCopy(
+    pointer: SegmentPointer,
+    last: SegmentPointer,
+  ): JsonPointer =
+    with(pointer) {
+      if (next is SegmentPointer) {
+        SegmentPointer(
+          propertyName = propertyName,
+          index = index,
+          next = insertLastDeepCopy(next, last),
         )
-      node = node.next
+      } else {
+        SegmentPointer(
+          propertyName = propertyName,
+          index = index,
+          next = last,
+        )
+      }
     }
-    return buildPath(last, parent)
-  }
 
   private fun escapeJsonPointer(propertyName: String): String {
     if (propertyName.contains(SEPARATOR) || propertyName.contains(QUOTATION)) {

src/commonMain/kotlin/io/github/optimumcode/json/schema/OutputCollector.kt

@@ -263,12 +263,23 @@ public sealed class OutputCollector<T> private constructor(
     private val collapse: Boolean = true,
     transformer: OutputErrorTransformer<ValidationOutput.Detailed> = NO_TRANSFORMATION,
   ) : OutputCollector<ValidationOutput.Detailed>(parent, transformer) {
-    private val errors: MutableList<ValidationOutput.Detailed> = mutableListOf()
+    private lateinit var results: MutableSet<ValidationOutput.Detailed>
+
+    private fun addResult(result: ValidationOutput.Detailed) {
+      if (result.valid) {
+        // do not add valid
+        return
+      }
+      if (!::results.isInitialized) {
+        results = linkedSetOf()
+      }
+      results.add(result)
+    }
 
     override val output: ValidationOutput.Detailed
       get() {
-        val valid = errors.none { !it.valid }
-        if (valid) {
+        if (!::results.isInitialized) {
+          // variable is uninitialized only if all results are valid
           return Detailed(
             valid = true,
             keywordLocation = keywordLocation,
@@ -277,7 +288,7 @@ public sealed class OutputCollector<T> private constructor(
             errors = emptySet(),
           )
         }
-        val failed = errors.filterTo(hashSetOf()) { it.error != null || it.errors.isNotEmpty() }
+        val failed = results
         return if (failed.size == 1 && collapse) {
           failed.single()
         } else {
@@ -331,12 +342,12 @@ public sealed class OutputCollector<T> private constructor(
       Detailed(location, keywordLocation, parent, absoluteLocation, collapse, transformer = transformer)
 
     override fun reportErrors() {
-      parent?.errors?.add(output)
+      parent?.addResult(output)
     }
 
     override fun onError(error: ValidationError) {
       val err = transformError(error) ?: return
-      errors.add(
+      addResult(
         Detailed(
           valid = false,
           instanceLocation = err.objectPath,
@@ -355,14 +366,20 @@ public sealed class OutputCollector<T> private constructor(
     private val absoluteLocation: AbsoluteLocation? = null,
     transformer: OutputErrorTransformer<ValidationOutput.Verbose> = NO_TRANSFORMATION,
   ) : OutputCollector<ValidationOutput.Verbose>(parent, transformer) {
-    private val errors: MutableList<ValidationOutput.Verbose> = mutableListOf()
+    private val results: MutableList<ValidationOutput.Verbose> = ArrayList(1)
+
+    private fun addResult(result: ValidationOutput.Verbose) {
+      // init hashCode to reduce overhead in future
+      result.hashCode()
+      results.add(result)
+    }
 
     override val output: ValidationOutput.Verbose
       get() {
-        if (errors.size == 1) {
+        if (results.size == 1) {
           // when this is a leaf we should return the reported error
           // instead of creating a new node
-          val childError = errors.single()
+          val childError = results.single()
           if (
             childError.errors.isEmpty() &&
             childError.let {
@@ -373,11 +390,11 @@ public sealed class OutputCollector<T> private constructor(
           }
         }
         return Verbose(
-          valid = errors.none { !it.valid },
+          valid = results.none { !it.valid },
           keywordLocation = keywordLocation,
           absoluteKeywordLocation = absoluteLocation,
           instanceLocation = location,
-          errors = errors.toSet(),
+          errors = results.toSet(),
         )
       }
 
@@ -422,12 +439,12 @@ public sealed class OutputCollector<T> private constructor(
       Verbose(location, keywordLocation, parent, absoluteLocation, transformer)
 
     override fun reportErrors() {
-      parent?.errors?.add(output)
+      parent?.addResult(output)
     }
 
     override fun onError(error: ValidationError) {
       val err = transformError(error) ?: return
-      errors.add(
+      addResult(
         Verbose(
           valid = false,
           instanceLocation = err.objectPath,

src/commonMain/kotlin/io/github/optimumcode/json/schema/ValidationOutput.kt

@@ -35,7 +35,43 @@ public sealed class ValidationOutput private constructor() {
     public val absoluteKeywordLocation: AbsoluteLocation? = null,
     public val error: String? = null,
     public val errors: Set<Detailed> = emptySet(),
-  ) : ValidationOutput()
+  ) : ValidationOutput() {
+    // hashcode is stored to avoid recursive recalculation for each error in `errors` property
+    private var hash = 0
+
+    override fun equals(other: Any?): Boolean {
+      if (this === other) return true
+      if (other == null || this::class != other::class) return false
+
+      other as Detailed
+
+      if (valid != other.valid) return false
+      if (keywordLocation != other.keywordLocation) return false
+      if (instanceLocation != other.instanceLocation) return false
+      if (absoluteKeywordLocation != other.absoluteKeywordLocation) return false
+      if (error != other.error) return false
+      if (errors != other.errors) return false
+
+      return true
+    }
+
+    override fun hashCode(): Int {
+      if (hash != 0) {
+        return hash
+      }
+      var result = valid.hashCode()
+      result = 31 * result + keywordLocation.hashCode()
+      result = 31 * result + instanceLocation.hashCode()
+      result = 31 * result + (absoluteKeywordLocation?.hashCode() ?: 0)
+      result = 31 * result + (error?.hashCode() ?: 0)
+      result = 31 * result + errors.hashCode()
+      if (result == 0) {
+        result = 31
+      }
+      hash = result
+      return result
+    }
+  }
 
   public data class Verbose(
     override val valid: Boolean,
@@ -44,6 +80,41 @@ public sealed class ValidationOutput private constructor() {
     public val absoluteKeywordLocation: AbsoluteLocation? = null,
     public val error: String? = null,
     public val errors: Set<Verbose> = emptySet(),
-    public val annotations: Set<Verbose> = emptySet(),
-  ) : ValidationOutput()
+  ) : ValidationOutput() {
+    // hashcode is stored to avoid recursive recalculation for each error in `errors` property
+    private var hash = 0
+
+    override fun equals(other: Any?): Boolean {
+      if (this === other) return true
+      if (other == null || this::class != other::class) return false
+
+      other as Verbose
+
+      if (valid != other.valid) return false
+      if (keywordLocation != other.keywordLocation) return false
+      if (instanceLocation != other.instanceLocation) return false
+      if (absoluteKeywordLocation != other.absoluteKeywordLocation) return false
+      if (error != other.error) return false
+      if (errors != other.errors) return false
+
+      return true
+    }
+
+    override fun hashCode(): Int {
+      if (hash != 0) {
+        return hash
+      }
+      var result = valid.hashCode()
+      result = 31 * result + keywordLocation.hashCode()
+      result = 31 * result + instanceLocation.hashCode()
+      result = 31 * result + (absoluteKeywordLocation?.hashCode() ?: 0)
+      result = 31 * result + (error?.hashCode() ?: 0)
+      result = 31 * result + errors.hashCode()
+      if (result == 0) {
+        result = 31
+      }
+      hash = result
+      return result
+    }
+  }
 }