Merge branch 'dev'

# Conflicts:
#	version.txt

Author: clauret

src/main/java/org/pageseeder/diffx/action/ActionsBuffer.java

@@ -24,8 +24,9 @@
 
 /**
  * Generates a list of actions from the output of the algorithms.
- * <p>
- * This handler is useful to capture the operations resulting from a diff and generate and edit script.
+ *
+ * <p>This handler is useful to capture the operations resulting from a diff
+ * and generate and edit script.
  *
  * @author Christophe Lauret
  *
@@ -49,6 +50,7 @@ public class ActionsBuffer<T> implements DiffHandler<T> {
   @Override
   public void handle(Operator operator, T token) {
     setupAction(operator);
+    assert this.action != null; // setupAction ensures it
     this.action.add(token);
   }
 

src/main/java/org/pageseeder/diffx/algorithm/ElementStackFilter.java

@@ -18,6 +18,7 @@
 import org.jspecify.annotations.Nullable;
 import org.pageseeder.diffx.action.Operation;
 import org.pageseeder.diffx.api.DiffHandler;
+import org.pageseeder.diffx.api.Equality;
 import org.pageseeder.diffx.api.Operator;
 import org.pageseeder.diffx.handler.DiffFilter;
 import org.pageseeder.diffx.token.AttributeToken;
@@ -53,6 +54,20 @@ public final class ElementStackFilter extends DiffFilter<XMLToken> {
    */
   private final Deque<Operation<StartElementToken>> elements;
 
+  private final Equality<XMLToken> eq;
+
+  /**
+   * Constructs a new ElementStackFilter with a specified target handler.
+   *
+   * @param target The target handler that will be used to process XML tokens.
+   * @param eq The strategy to compare elements for equality.
+   */
+  public ElementStackFilter(DiffHandler<XMLToken> target, Equality<XMLToken> eq) {
+    super(target);
+    this.elements = new ArrayDeque<>(16);
+    this.eq = eq;
+  }
+
   /**
    * Constructs a new ElementStackFilter with a specified target handler.
    *
@@ -61,6 +76,7 @@ public final class ElementStackFilter extends DiffFilter<XMLToken> {
   public ElementStackFilter(DiffHandler<XMLToken> target) {
     super(target);
     this.elements = new ArrayDeque<>(16);
+    this.eq = XMLToken::equals;
   }
 
   /**
@@ -145,7 +161,7 @@ public boolean isAllowed(Operator operator, XMLToken token) {
   public boolean matchCurrent(Operator operator, StartElementToken start) {
     Operation<StartElementToken> current = this.current();
     if (current == null) return false;
-    return operator == current.operator() && start.equals(current.token());
+    return operator == current.operator() && this.eq.equals(start, current.token());
   }
 
   /**

src/main/java/org/pageseeder/diffx/algorithm/HirschbergAlgorithm.java

@@ -17,6 +17,7 @@
 
 import org.pageseeder.diffx.api.DiffAlgorithm;
 import org.pageseeder.diffx.api.DiffHandler;
+import org.pageseeder.diffx.api.Equality;
 import org.pageseeder.diffx.api.Operator;
 
 import java.util.List;
@@ -37,7 +38,7 @@
  *
  * @author Christophe Lauret
  *
- * @version 1.3.0
+ * @version 1.3.1
  * @since 0.9.0
  */
 public final class HirschbergAlgorithm<T> implements DiffAlgorithm<T> {
@@ -47,6 +48,27 @@ public final class HirschbergAlgorithm<T> implements DiffAlgorithm<T> {
    */
   private static final boolean DEBUG = false;
 
+  /**
+   * Determines the strategy to compare elements for equality within the diff algorithm.
+   */
+  private final Equality<T> eq;
+
+  /**
+   * Default constructor using token equality.
+   */
+  public HirschbergAlgorithm() {
+    this.eq = T::equals;
+  }
+
+  /**
+   * Constructor specifying the equality strategy.
+   *
+   * @param eq The strategy to compare elements for equality.
+   */
+  public HirschbergAlgorithm(Equality<T> eq) {
+    this.eq = eq;
+  }
+
   @Override
   public void diff(List<? extends T> from, List<? extends T> to, DiffHandler<T> handler) {
     // It is more efficient to supply the sizes than retrieve from lists
@@ -58,12 +80,12 @@ public void diff(List<? extends T> from, List<? extends T> to, DiffHandler<T> ha
    *
    * @return the last line of the Needleman-Wunsch score matrix
    */
-  private static <T> int[] algorithmB(int m, int n, List<? extends T> a, List<? extends T> b) {
+  private int[] algorithmB(int m, int n, List<? extends T> a, List<? extends T> b) {
     int[][] k = new int[2][n + 1];
     for (int i = 1; i <= m; i++) {
       if (n + 1 >= 0) System.arraycopy(k[1], 0, k[0], 0, n + 1);
       for (int j = 1; j <= n; j++) {
-        if (a.get(i - 1).equals(b.get(j - 1))) {
+        if (this.eq.equals(a.get(i - 1), b.get(j - 1))) {
           k[1][j] = k[0][j - 1] + 1;
         } else {
           k[1][j] = Math.max(k[1][j - 1], k[0][j]);
@@ -78,12 +100,12 @@ private static <T> int[] algorithmB(int m, int n, List<? extends T> a, List<? ex
    *
    * <p>Implementation note: we traverse the list in reverse, it is more efficient than reversing the lists.
    */
-  private static <T> int[] algorithmBRev(int m, int n, List<? extends T> a, List<? extends T> b) {
+  private int[] algorithmBRev(int m, int n, List<? extends T> a, List<? extends T> b) {
     int[][] k = new int[2][n + 1];
     for (int i = m - 1; i >= 0; i--) {
       if (n + 1 >= 0) System.arraycopy(k[1], 0, k[0], 0, n + 1);
       for (int j = n - 1; j >= 0; j--) {
-        if (a.get(i).equals(b.get(j))) {
+        if (this.eq.equals(a.get(i), b.get(j))) {
           k[1][n - j] = k[0][n - j - 1] + 1;
         } else {
           k[1][n - j] = Math.max(k[1][n - j - 1], k[0][n - j]);
@@ -113,7 +135,7 @@ private static int findK(int[] l1, int[] l2, int n) {
    * Algorithm C as described by Hirschberg
    */
   @SuppressWarnings("java:S106")
-  private static <T> void algorithmC(int m, int n, List<? extends T> a, List<? extends T> b, DiffHandler<T> handler) {
+  private void algorithmC(int m, int n, List<? extends T> a, List<? extends T> b, DiffHandler<T> handler) {
     if (DEBUG) System.out.print("[m=" + m + ",n=" + n + "," + a + "," + b + "] ->");
 
     if (n == 0) {
@@ -133,7 +155,7 @@ private static <T> void algorithmC(int m, int n, List<? extends T> a, List<? ext
       boolean match = false;
       T a0 = a.get(0);
       for (int j = 0; j < n; j++) {
-        if (a0.equals(b.get(j)) && !match) {
+        if (this.eq.equals(a0, b.get(j)) && !match) {
           handler.handle(Operator.MATCH, a0);
           match = true;
         } else {

src/main/java/org/pageseeder/diffx/algorithm/KumarRanganAlgorithm.java

@@ -17,6 +17,7 @@
 
 import org.pageseeder.diffx.api.DiffAlgorithm;
 import org.pageseeder.diffx.api.DiffHandler;
+import org.pageseeder.diffx.api.Equality;
 import org.pageseeder.diffx.api.Operator;
 
 import java.util.List;
@@ -35,18 +36,41 @@
  * XML sequences as it cannot always produce well-formed XML.
  *
  * @author Christophe Lauret
- * @version 0.9.0
+ *
+ * @version 1.3.1
+ * @since 0.9.0
  */
 public final class KumarRanganAlgorithm<T> implements DiffAlgorithm<T> {
 
+  /**
+   * Determines the strategy to compare elements for equality within the diff algorithm.
+   */
+  private final Equality<T> eq;
+
+  /**
+   * Default constructor using token equality.
+   */
+  public KumarRanganAlgorithm() {
+    this.eq = T::equals;
+  }
+
+  /**
+   * Constructor specifying the equality strategy.
+   *
+   * @param eq The strategy to compare elements for equality.
+   */
+  public KumarRanganAlgorithm(Equality<T> eq) {
+    this.eq = eq;
+  }
+
   /**
    * Set to <code>true</code> to show debug info.
    */
   private static final boolean DEBUG = false;
 
   @Override
   public void diff(List<? extends T> from, List<? extends T> to, DiffHandler<T> handler) {
-    Instance<T> instance = new Instance<>(from, to);
+    Instance<T> instance = new Instance<>(from, to, eq);
     instance.process(handler);
   }
 
@@ -78,6 +102,8 @@ private static class Instance<T> {
     private int R;
     private int S;
 
+    private final Equality<T> eq;
+
     /**
      * A counter for the index of the second sequence when generating the diff.
      */
@@ -91,9 +117,10 @@ private static class Instance<T> {
      */
     private DiffHandler<T> handler;
 
-    Instance(List<? extends T> from, List<? extends T> to) {
+    Instance(List<? extends T> from, List<? extends T> to, Equality<T> eq) {
       this.A = Objects.requireNonNull(from);
       this.B = Objects.requireNonNull(to);
+      this.eq = eq;
     }
 
     /**
@@ -235,8 +262,7 @@ private void fillOne(int startA, int endA, int startB, int endB, int m, int n, i
 
         // The real index in the global char table is:
         // current_index * sign + beginning index of the sub-char array
-        while (posB > lowerB && !this.A.get((i - 1) * sign + startA)
-            .equals(this.B.get((posB - 1) * sign + startB))) {
+        while (posB > lowerB && !this.eq.equals(this.A.get((i - 1) * sign + startA), this.B.get((posB - 1) * sign + startB))) {
           posB--;
         }
         int temp = Math.max(posB, lowerB);
@@ -361,7 +387,7 @@ private void computeLCSBaseCase(int startA, int endA, int startB, int endB, int
       int i = 0;
 
       // 2. Start in order for the A subsequence and get the index of the B subsequence
-      while (i < p && this.A.get(i + startA).equals(this.B.get(this.LL[p - i] - 1 + startB))) {
+      while (i < p && this.eq.equals(this.A.get(i + startA), this.B.get(this.LL[p - i] - 1 + startB))) {
         this.handler.handle(Operator.MATCH, this.A.get(i + startA));
         this.J++;
         i++;
@@ -385,7 +411,7 @@ private void computeLCSBaseCase(int startA, int endA, int startB, int endB, int
         this.J++;
         i++;
 
-        while (i < m && this.J < endB && !this.A.get(i + startA).equals(this.B.get(this.J))) {
+        while (i < m && this.J < endB && !this.eq.equals(this.A.get(i + startA), this.B.get(this.J))) {
           insertUpTo(this.J + 1);
         }
       }

src/main/java/org/pageseeder/diffx/algorithm/MatrixProcessor.java

@@ -15,6 +15,8 @@
  */
 package org.pageseeder.diffx.algorithm;
 
+import org.pageseeder.diffx.api.Equality;
+import org.pageseeder.diffx.token.XMLToken;
 import org.pageseeder.diffx.xml.Sequence;
 
 import java.io.PrintStream;
@@ -24,7 +26,8 @@
  * Build the matrix for the specified tokens using dynamic programming.
  *
  * @author Christophe Lauret
- * @version 1.2.0
+ *
+ * @version 1.3.1
  * @since 0.9.0
  */
 public final class MatrixProcessor<T> {
@@ -42,7 +45,18 @@ public void setInverse(boolean inverse) {
    * @return the matrix using dynamic programming
    */
   public Matrix process(Sequence first, Sequence second) {
-    return this.inverse ? computeInverse(first.tokens(), second.tokens()) : compute(first.tokens(), second.tokens());
+    return process(first, second, XMLToken::equals);
+  }
+
+  /**
+   * @param first  The first sequence of tokens to test.
+   * @param second The second sequence of tokens to test.
+   * @param eq The strategy to compare elements for equality.
+   *
+   * @return the matrix using dynamic programming
+   */
+  public Matrix process(Sequence first, Sequence second, Equality<XMLToken> eq) {
+    return this.inverse ? computeInverse(first.tokens(), second.tokens(), eq) : compute(first.tokens(), second.tokens(), eq);
   }
 
   /**
@@ -52,10 +66,21 @@ public Matrix process(Sequence first, Sequence second) {
    * @return the matrix using dynamic programming
    */
   public Matrix process(List<? extends T> first, List<? extends T> second) {
-    return this.inverse ? computeInverse(first, second) : compute(first, second);
+    return process(first, second, T::equals);
+  }
+
+  /**
+   * @param first  The first sequence of tokens to test.
+   * @param second The second sequence of tokens to test.
+   * @param eq The strategy to compare elements for equality.
+   *
+   * @return the matrix using dynamic programming
+   */
+  public Matrix process(List<? extends T> first, List<? extends T> second, Equality<T> eq) {
+    return this.inverse ? computeInverse(first, second, eq) : compute(first, second, eq);
   }
 
-  private static <T> Matrix compute(List<? extends T> first, List<? extends T> second) {
+  private static <T> Matrix compute(List<? extends T> first, List<? extends T> second, Equality<T> eq) {
     Matrix matrix = getMatrix(first, second, false);
     int length1 = first.size();
     int length2 = second.size();
@@ -67,7 +92,7 @@ private static <T> Matrix compute(List<? extends T> first, List<? extends T> sec
         if (i == 0 || j == 0) {
           matrix.set(i, j, 0);
         } else {
-          if (first.get(i - 1).equals(second.get(j - 1))) {
+          if (eq.equals(first.get(i - 1), second.get(j - 1))) {
             // the tokens are the same
             matrix.incrementPath(i, j);
           } else {
@@ -80,7 +105,7 @@ private static <T> Matrix compute(List<? extends T> first, List<? extends T> sec
     return matrix;
   }
 
-  private static <T> Matrix computeInverse(List<? extends T> first, List<? extends T> second) {
+  private static <T> Matrix computeInverse(List<? extends T> first, List<? extends T> second, Equality<T> eq) {
     Matrix matrix = getMatrix(first, second, true);
     int length1 = first.size();
     int length2 = second.size();
@@ -92,7 +117,7 @@ private static <T> Matrix computeInverse(List<? extends T> first, List<? extends
         if (i >= length1 || j >= length2) {
           matrix.set(i, j, 0);
         } else {
-          if (first.get(i).equals(second.get(j))) {
+          if (eq.equals(first.get(i), second.get(j))) {
             // the tokens are the same
             matrix.incrementPath(i, j);
           } else {