Add an alternative strategy for joining pointers with big length

Author: OptimumCode

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

@@ -31,7 +31,13 @@ public sealed class JsonPointer(
    */
   public fun atIndex(index: Int): JsonPointer {
     require(index >= 0) { "negative index: $index" }
-    return atProperty(index.toString())
+    return insertLast(
+      SegmentPointer(
+        propertyName = index.toString(),
+        depth = 1,
+        index = index,
+      ),
+    )
   }
 
   /**
@@ -42,7 +48,10 @@ public sealed class JsonPointer(
    * val pointer = JsonPointer.ROOT.atProperty("prop1").atProperty("prop2")  // "/prop1/prop2"
    * ```
    */
-  public fun atProperty(property: String): JsonPointer = insertLast(SegmentPointer(property))
+  public fun atProperty(property: String): JsonPointer =
+    insertLast(
+      SegmentPointer(depth = 1, propertyName = property),
+    )
 
   override fun toString(): String {
     val str = asString
@@ -68,7 +77,33 @@ public sealed class JsonPointer(
     if (this !is SegmentPointer) {
       return last
     }
-    return insertLastDeepCopy(this, last)
+    if (depth < MAX_POINTER_DEPTH_FOR_RECURSIVE_INSERT) {
+      return insertLastDeepCopy(this, last)
+    }
+    // avoid recursion when pointer depth is greater than a specified limit
+    // this should help with avoiding stack-overflow error
+    // when this method called for a pointer that has too many segments
+    //
+    // Using queue is less efficient than recursion (around 10%) but saves us from crash
+    val queue = ArrayDeque<SegmentPointer>(depth)
+    var cur: JsonPointer = this
+    while (cur is SegmentPointer) {
+      queue.add(cur)
+      cur = cur.next
+    }
+    val additionalDepth = last.depth
+    var result = last
+    while (queue.isNotEmpty()) {
+      val segment = queue.removeLast()
+      result =
+        SegmentPointer(
+          propertyName = segment.propertyName,
+          depth = segment.depth + additionalDepth,
+          index = segment.index,
+          next = result,
+        )
+    }
+    return result
   }
 
   // there might be an issue with stack in case this function is called deep on the stack
@@ -77,15 +112,18 @@ public sealed class JsonPointer(
     last: SegmentPointer,
   ): JsonPointer =
     with(pointer) {
+      val additionalDepth = last.depth
       if (next is SegmentPointer) {
         SegmentPointer(
           propertyName = propertyName,
+          depth = depth + additionalDepth,
           index = index,
           next = insertLastDeepCopy(next, last),
         )
       } else {
         SegmentPointer(
           propertyName = propertyName,
+          depth = depth + additionalDepth,
           index = index,
           next = last,
         )
@@ -145,6 +183,7 @@ public sealed class JsonPointer(
   }
 
   public companion object {
+    private const val MAX_POINTER_DEPTH_FOR_RECURSIVE_INSERT = 20
     internal const val SEPARATOR: Char = '/'
     internal const val QUOTATION: Char = '~'
     internal const val QUOTATION_ESCAPE: Char = '0'
@@ -187,13 +226,15 @@ public sealed class JsonPointer(
       lastSegment: SegmentPointer,
       parent: PointerParent?,
     ): JsonPointer {
+      var depth = lastSegment.depth
       var curr = lastSegment
       var parentValue = parent
       while (parentValue != null) {
         curr =
           parentValue.run {
             SegmentPointer(
               segment,
+              ++depth,
               curr,
             )
           }
@@ -283,6 +324,7 @@ internal object EmptyPointer : JsonPointer()
 
 internal class SegmentPointer(
   val propertyName: String,
+  val depth: Int = 1,
   override val next: JsonPointer = EmptyPointer,
   val index: Int = parseIndex(propertyName),
 ) : JsonPointer(next) {

src/commonTest/kotlin/io/github/optimumcode/json/pointer/JsonPointerTest.kt

@@ -49,7 +49,7 @@ class JsonPointerTest : FunSpec() {
     test("extracts segment path") {
       val pointer = JsonPointer("/first/second")
       assertSoftly {
-        pointer.assertSegment(property = "first")
+        pointer.assertSegment(property = "first", depth = 2)
         val next = pointer.next
         next shouldNotBe null
         next!!.assertSegment(property = "second")
@@ -68,7 +68,7 @@ class JsonPointerTest : FunSpec() {
 
       test("parses several escaped characters '$escaped' as '$actual'") {
         val pointer = JsonPointer("/${escaped}and$escaped/test")
-        pointer.assertSegment("${actual}and$actual")
+        pointer.assertSegment("${actual}and$actual", depth = 2)
         pointer.next.apply {
           shouldNotBe(null)
           this!!.assertSegment("test")
@@ -84,7 +84,7 @@ class JsonPointerTest : FunSpec() {
     test("empty segment in the end") {
       val pointer = JsonPointer("/test/")
       assertSoftly {
-        pointer.assertSegment(property = "test")
+        pointer.assertSegment(property = "test", depth = 2)
         pointer.next
           .shouldNotBeNull()
           .assertSegment(property = "")
@@ -104,9 +104,9 @@ class JsonPointerTest : FunSpec() {
     test("empty segment in the middle") {
       val pointer = JsonPointer("/test1//test2")
       assertSoftly {
-        pointer.assertSegment(property = "test1")
+        pointer.assertSegment(property = "test1", depth = 3)
         var next = pointer.next.shouldNotBeNull()
-        next.assertSegment(property = "")
+        next.assertSegment(property = "", depth = 2)
         next = next.next.shouldNotBeNull()
         next.assertSegment(property = "test2")
         pointer.toString() shouldBe "/test1//test2"
@@ -150,12 +150,14 @@ class JsonPointerTest : FunSpec() {
   private fun JsonPointer.assertSegment(
     property: String,
     index: Int = -1,
+    depth: Int = 1,
   ) {
     asClue {
       this should beOfType<SegmentPointer>()
       this as SegmentPointer
       this.propertyName shouldBe property
       this.index shouldBe index
+      this.depth shouldBe depth
     }
   }
 }