refactoring more by using more helper structures

Author: roddi

Diff/DiffArray.swift

@@ -232,145 +232,136 @@ private func diff_computeDiffsBetweenArrays<T: Equatable>(arrayA: [T], arrayB: [
     return diff_bisectOfArrays(arrayA: arrayA, arrayB: arrayB)
 }
 
-private struct FrontPathParameters<T> {
-    let currentD: Int
+private class Kay {
+    var start: Int = 0
+    var end: Int = 0
+    var index: Int = 0
+}
+
+private struct CommonPathParameters<T: Equatable> {
     let vOffset: Int
     let inArrayA: [T]
     let inArrayB: [T]
+    let front: Bool
+    let delta: Int
+    let vLength: Int
 }
 
-// swiftlint:disable function_parameter_count
-private func walkFrontPath<T>(parameters: FrontPathParameters<T>,
-                              kIndex1: inout Int,
-                              k1end: inout Int,
-                              vectors1: inout [Int],
-                              k1start: inout Int,
-                              front: Bool,
-                              delta: Int,
-                              vLength: Int,
-                              vectors2: inout [Int],
-                              diffs: inout [Diff<T>]) -> Bool {
-
-    var haveFoundDiffs = false // assume
-    while kIndex1 <= parameters.currentD - k1end {
+private func walkFrontPath<T: Equatable>(
+    commonParameters: CommonPathParameters<T>,
+    currentD: Int,
+    kay1: Kay,
+    vectors1: inout [Int],
+    vectors2: inout [Int]) -> [Diff<T>] {
+
+    while kay1.index <= currentD - kay1.end {
         defer {
-            kIndex1 += 2
+            kay1.index += 2
         }
-        let k1Offset = parameters.vOffset + kIndex1
+        let k1Offset = commonParameters.vOffset + kay1.index
         var x1 = 0
 
-        if kIndex1 == -parameters.currentD || (kIndex1 != parameters.currentD && vectors1[k1Offset - 1] < vectors1[k1Offset + 1]) {
+        if kay1.index == -currentD || (kay1.index != currentD && vectors1[k1Offset - 1] < vectors1[k1Offset + 1]) {
             x1 = vectors1[k1Offset + 1]
         } else {
             x1 = vectors1[k1Offset - 1] + 1
         }
 
-        var y1 = x1 - kIndex1
+        var y1 = x1 - kay1.index
 
         // follow the snake!
-        while x1 < parameters.inArrayA.count && y1 < parameters.inArrayB.count && parameters.inArrayA[x1] == parameters.inArrayB[y1] {
+        while x1 < commonParameters.inArrayA.count && y1 < commonParameters.inArrayB.count && commonParameters.inArrayA[x1] == commonParameters.inArrayB[y1] {
             x1 += 1
             y1 += 1
         }
 
         vectors1[k1Offset] = x1
 
-        if x1 > parameters.inArrayA.count {
+        if x1 > commonParameters.inArrayA.count {
             // Ran off the right of the graph.
-            k1end += 2
-        } else if y1 > parameters.inArrayB.count {
+            kay1.end += 2
+        } else if y1 > commonParameters.inArrayB.count {
             // Ran off the bottom of the graph.
-            k1start += 2
-        } else if front {
-            let k2Offset = parameters.vOffset + delta - kIndex1
+            kay1.start += 2
+        } else if commonParameters.front {
+            let k2Offset = commonParameters.vOffset + commonParameters.delta - kay1.index
 
-            if k2Offset >= 0 && k2Offset < vLength && vectors2[k2Offset] != -1 {
+            if k2Offset >= 0 && k2Offset < commonParameters.vLength && vectors2[k2Offset] != -1 {
                 // Mirror x2 onto top-left coordinate system.
-                let x2 = parameters.inArrayA.count - vectors2[k2Offset]
+                let x2 = commonParameters.inArrayA.count - vectors2[k2Offset]
                 if x1 >= x2 {
                     // diffs = diff_bisectSplitOfStrings(text1, text2, x1, y1, properties);
-                    diffs = diff_bisectSplitOfArrays(arrayA: parameters.inArrayA, arrayB: parameters.inArrayB, x: x1, y: y1)
-                    haveFoundDiffs = true
-                    break
+                    return diff_bisectSplitOfArrays(arrayA: commonParameters.inArrayA, arrayB: commonParameters.inArrayB, x: x1, y: y1)
                 }
             }
         }
     }
-
-    return haveFoundDiffs
+    return []
 }
 
-private func walkReversePath<T: Equatable>(kIndex2: inout Int,
-                                           currentD: Int,
-                                           k2end: inout Int,
-                                           vOffset: Int,
-                                           vectors2: inout [Int],
-                                           inArrayA: [T],
-                                           inArrayB: [T],
-                                           k2start: inout Int,
-                                           front: Bool,
-                                           delta: Int,
-                                           vLength: Int,
-                                           vectors1: inout [Int],
-                                           diffs: inout [Diff<T>],
-                                           haveFoundDiffs: inout Bool) {
-    while kIndex2 <= currentD - k2end {
+private func walkReversePath<T: Equatable>(
+    commonParameters: CommonPathParameters<T>,
+    currentD: Int,
+    kay2: Kay,
+    vectors1: inout [Int],
+    vectors2: inout [Int]) -> [Diff<T>] {
+
+    while kay2.index <= currentD - kay2.end {
 
         defer {
-            kIndex2 += 2
+            kay2.index += 2
         }
-        let k2Offset = vOffset + kIndex2
+        let k2Offset = commonParameters.vOffset + kay2.index
         var x2 = 0
 
-        if kIndex2 == -currentD || (kIndex2 != currentD && vectors2[k2Offset - 1] < vectors2[k2Offset + 1]) {
+        if kay2.index == -currentD || (kay2.index != currentD && vectors2[k2Offset - 1] < vectors2[k2Offset + 1]) {
             x2 = vectors2[k2Offset + 1]
         } else {
             x2 = vectors2[k2Offset - 1] + 1
         }
 
-        var y2 = x2 - kIndex2
+        var y2 = x2 - kay2.index
 
-        while x2 < inArrayA.count && y2 < inArrayB.count && (inArrayA[inArrayA.count - x2 - 1] == inArrayB[inArrayB.count - y2 - 1]) {
+        while x2 < commonParameters.inArrayA.count && y2 < commonParameters.inArrayB.count && (commonParameters.inArrayA[commonParameters.inArrayA.count - x2 - 1] == commonParameters.inArrayB[commonParameters.inArrayB.count - y2 - 1]) {
             x2 += 1
             y2 += 1
         }
 
         vectors2[k2Offset] = x2
 
-        if x2 > inArrayA.count {
+        if x2 > commonParameters.inArrayA.count {
             // Ran off the left of the graph.
-            k2end += 2
-        } else if y2 > inArrayB.count {
+            kay2.end += 2
+        } else if y2 > commonParameters.inArrayB.count {
             // Ran off the top of the graph.
-            k2start += 2
-        } else if !front {
-            let k1Offset = vOffset + delta - kIndex2
+            kay2.start += 2
+        } else if !commonParameters.front {
+            let k1Offset = commonParameters.vOffset + commonParameters.delta - kay2.index
 
-            if k1Offset >= 0 && k1Offset < vLength && vectors1[k1Offset] != -1 {
+            if k1Offset >= 0 && k1Offset < commonParameters.vLength && vectors1[k1Offset] != -1 {
                 let x1 = vectors1[k1Offset]
-                let y1 = vOffset + x1 - k1Offset
+                let y1 = commonParameters.vOffset + x1 - k1Offset
                 // Mirror x2 onto top-left coordinate system.
-                x2 = inArrayA.count - x2
+                x2 = commonParameters.inArrayA.count - x2
 
                 if x1 >= x2 {
                     // Overlap detected.
-                    diffs = diff_bisectSplitOfArrays(arrayA: inArrayA, arrayB: inArrayB, x: x1, y: y1)
-                    haveFoundDiffs = true
-                    break
+                    return diff_bisectSplitOfArrays(arrayA: commonParameters.inArrayA, arrayB: commonParameters.inArrayB, x: x1, y: y1)
                 }
             }
         }
     }
+    return []
 }
 
 // yes this method is way too long. Pull requests welcome!
-func diff_bisectOfArrays<T: Equatable>(arrayA inArrayA: [T], arrayB inArrayB: [T]) -> [Diff<T>] {
-    let arrayALength = inArrayA.count
-    let arrayBLength = inArrayB.count
-    var haveFoundDiffs = false
-    var diffs: [Diff<T>]  = []
+private func debugPrint(kay: Kay, vectors1: [Int], vectors2: [Int]) {
+    print("--- kIndex: \(kay.index), kstart: \(kay.start), kend: \(kay.end), ")
+    print("--- vectors1: \(vectors1), vectors2: \(vectors2)")
+}
 
-    let maxD = (arrayALength + arrayBLength + 1) / 2
+func diff_bisectOfArrays<T: Equatable>(arrayA inArrayA: [T], arrayB inArrayB: [T]) -> [Diff<T>] {
+    let maxD = (inArrayA.count + inArrayB.count + 1) / 2
     let vOffset = maxD
     var vLength = 2 * maxD
 
@@ -385,72 +376,59 @@ func diff_bisectOfArrays<T: Equatable>(arrayA inArrayA: [T], arrayB inArrayB: [T
         vectors1.append(-1)
         vectors2.append(-1)
     }
-
     vectors1[vOffset + 1] = 0
     vectors2[vOffset + 1] = 0
 
-    let delta = arrayALength - arrayBLength
+    let delta = inArrayA.count - inArrayB.count
 
     // If the total number of characters is odd, then the front path will collide with the reverse path.
     let front = delta % 2 != 0
 
     // Offsets for start and end of k loop. Prevents mapping of space beyond the grid.
-    var k1start = 0
-    var k1end = 0
-    var k2start = 0
-    var k2end = 0
+    let kay1 = Kay()
+    let kay2 = Kay()
+
+    let commonParameters = CommonPathParameters(vOffset: vOffset, inArrayA: inArrayA, inArrayB: inArrayB, front: front, delta: delta, vLength: vLength)
 
-    //
     for currentD in 0..<maxD {
 
         // Walk the front path one step.
-        var kIndex1 = -currentD + k1start
-
-        let parameters = FrontPathParameters(currentD: currentD, vOffset: vOffset, inArrayA: inArrayA, inArrayB: inArrayB)
-        if walkFrontPath(
-            parameters: parameters,
-            kIndex1: &kIndex1,
-                      k1end: &k1end,
-                      vectors1: &vectors1,
-                      k1start: &k1start,
-                      front: front,
-                      delta: delta,
-                      vLength: vLength,
-                      vectors2: &vectors2,
-                      diffs: &diffs) {
-            haveFoundDiffs = true
-            break
+        kay1.index = -currentD + kay1.start
+        debugPrint(kay: kay1, vectors1: vectors1, vectors2: vectors2)
+
+        let frontDiffs = walkFrontPath(
+            commonParameters: commonParameters,
+            currentD: currentD,
+            kay1: kay1,
+            vectors1: &vectors1,
+            vectors2: &vectors2)
+
+        debugPrint(kay: kay1, vectors1: vectors1, vectors2: vectors2)
+
+        if !frontDiffs.isEmpty {
+            return frontDiffs
         }
 
         // Walk the reverse path one step.
-        var kIndex2 = -currentD + k2start
-        walkReversePath(kIndex2: &kIndex2,
-                        currentD: currentD,
-                        k2end: &k2end,
-                        vOffset: vOffset,
-                        vectors2: &vectors2,
-                        inArrayA: inArrayA,
-                        inArrayB: inArrayB,
-                        k2start: &k2start,
-                        front: front,
-                        delta: delta,
-                        vLength: vLength,
-                        vectors1: &vectors1,
-                        diffs: &diffs,
-                        haveFoundDiffs: &haveFoundDiffs)
-
-        if haveFoundDiffs {
-            break
+        kay2.index = -currentD + kay2.start
+        debugPrint(kay: kay2, vectors1: vectors1, vectors2: vectors2)
+        let reverseDiffs = walkReversePath(
+            commonParameters: commonParameters,
+            currentD: currentD,
+            kay2: kay2,
+            vectors1: &vectors1,
+            vectors2: &vectors2)
+
+        debugPrint(kay: kay2, vectors1: vectors1, vectors2: vectors2)
+
+        if !reverseDiffs.isEmpty {
+            return reverseDiffs
         }
     }
 
-    if !haveFoundDiffs {
-        // we haven't found a snake at all so we couldn't cut the problem in half.
-        // This means we have no common element. Just add the diffs straight away.
-        diffs = [Diff(operation: .delete, array: inArrayA), Diff(operation: .insert, array: inArrayB)]
-    }
-
-    return diffs
+    // we haven't found a snake at all so we couldn't cut the problem in half.
+    // This means we have no common element. Just add the diffs straight away.
+    return [Diff(operation: .delete, array: inArrayA), Diff(operation: .insert, array: inArrayB)]
 }
 // swiftlint:enable function_body_length