Replace Object with generic type T (issue #22).

git-svn-id: http://java-diff-utils.googlecode.com/svn/trunk@52 d8d7d024-a22d-11de-b755-fd640f38fa9d

Author: simon.mittermueller@gmail.com

src/main/java/difflib/ChangeDelta.java

@@ -21,14 +21,17 @@
  * Describes the change-delta between original and revised texts.
  * 
  * @author <a href="dm.naumenko@gmail.com">Dmitry Naumenko</a>
+ * @param T The type of the compared elements in the 'lines'.
  */
-public class ChangeDelta extends Delta {
+public class ChangeDelta<T> extends Delta<T> {
 
     /**
-     * {@inheritDoc}
+     * Creates a change delta with the two given chunks.
+     * @param original The original chunk. Must not be {@code null}.
+     * @param revised The original chunk. Must not be {@code null}.
      */
-    public ChangeDelta(Chunk original, Chunk revised) {
-        super(original, revised);
+    public ChangeDelta(Chunk<T> original, Chunk<T>revised) {
+    	super(original, revised);
     }
 
     /**
@@ -37,15 +40,15 @@ public ChangeDelta(Chunk original, Chunk revised) {
      * @throws PatchFailedException
      */
     @Override
-    public void applyTo(List<Object> target) throws PatchFailedException {
+    public void applyTo(List<T> target) throws PatchFailedException {
         verify(target);
         int position = getOriginal().getPosition();
         int size = getOriginal().size();
         for (int i = 0; i < size; i++) {
             target.remove(position);
         }
         int i = 0;
-        for (Object line : getRevised().getLines()) {
+        for (T line : getRevised().getLines()) {
             target.add(position + i, line);
             i++;
         }
@@ -55,14 +58,14 @@ public void applyTo(List<Object> target) throws PatchFailedException {
      * {@inheritDoc}
      */
     @Override
-    public void restore(List<Object> target) {
+    public void restore(List<T> target) {
         int position = getRevised().getPosition();
         int size = getRevised().size();
         for (int i = 0; i < size; i++) {
             target.remove(position);
         }
         int i = 0;
-        for (Object line : getOriginal().getLines()) {
+        for (T line : getOriginal().getLines()) {
             target.add(position + i, line);
             i++;
         }
@@ -71,7 +74,7 @@ public void restore(List<Object> target) {
     /**
      * {@inheritDoc}
      */
-    public void verify(List<?> target) throws PatchFailedException {
+    public void verify(List<T> target) throws PatchFailedException {
         getOriginal().verify(target);
         if (getOriginal().getPosition() > target.size()) {
             throw new PatchFailedException("Incorrect patch for delta: "

src/main/java/difflib/Chunk.java

@@ -30,11 +30,12 @@
  * </p>
  * 
  * @author <a href="dm.naumenko@gmail.com>Dmitry Naumenko</a>
+ * @param T The type of the compared elements in the 'lines'.
  */
-public class Chunk {
+public class Chunk<T> {
 
     private final int position;
-    private List<?> lines;
+    private List<T> lines;
 
     /**
      * Creates a chunk and saves a copy of affected lines
@@ -44,7 +45,7 @@ public class Chunk {
      * @param lines
      *            the affected lines
      */
-    public Chunk(int position, List<?> lines) {
+    public Chunk(int position, List<T> lines) {
         this.position = position;
         this.lines = lines;
     }
@@ -57,7 +58,7 @@ public Chunk(int position, List<?> lines) {
      * @param lines
      *            the affected lines
      */
-    public Chunk(int position, Object[] lines) {
+    public Chunk(int position, T[] lines) {
         this.position = position;
         this.lines = Arrays.asList(lines);
     }
@@ -69,7 +70,7 @@ public Chunk(int position, Object[] lines) {
      * @param target
      *            the sequence to verify against.
      */
-    public void verify(List<?> target) throws PatchFailedException {
+    public void verify(List<T> target) throws PatchFailedException {
         if (last() > target.size()) {
             throw new PatchFailedException("Incorrect Chunk: the position of chunk > target size");
         }
@@ -88,14 +89,14 @@ public int getPosition() {
         return position;
     }
 
-    public void setLines(List<?> lines) {
+    public void setLines(List<T> lines) {
         this.lines = lines;
     }
 
     /**
      * @return the affected lines
      */
-    public List<?> getLines() {
+    public List<T> getLines() {
         return lines;
     }
 

src/main/java/difflib/DeleteDelta.java

@@ -21,13 +21,19 @@
  * Describes the delete-delta between original and revised texts.
  * 
  * @author <a href="dm.naumenko@gmail.com">Dmitry Naumenko</a>
+ * @param T The type of the compared elements in the 'lines'.
  */
-public class DeleteDelta extends Delta {
+public class DeleteDelta<T> extends Delta<T> {
 
-    /**
-     * {@inheritDoc}
-     */
-    public DeleteDelta(Chunk original, Chunk revised) {
+	/**
+	 * Creates a change delta with the two given chunks.
+	 * 
+	 * @param original
+	 *            The original chunk. Must not be {@code null}.
+	 * @param revised
+	 *            The original chunk. Must not be {@code null}.
+	 */
+    public DeleteDelta(Chunk<T> original, Chunk<T> revised) {
         super(original, revised);
     }
 
@@ -37,7 +43,7 @@ public DeleteDelta(Chunk original, Chunk revised) {
      * @throws PatchFailedException
      */
     @Override
-    public void applyTo(List<Object> target) throws PatchFailedException {
+    public void applyTo(List<T> target) throws PatchFailedException {
         verify(target);
         int position = getOriginal().getPosition();
         int size = getOriginal().size();
@@ -50,9 +56,9 @@ public void applyTo(List<Object> target) throws PatchFailedException {
      * {@inheritDoc}
      */
     @Override
-    public void restore(List<Object> target) {
+    public void restore(List<T> target) {
         int position = this.getRevised().getPosition();
-        List<?> lines = this.getOriginal().getLines();
+        List<T> lines = this.getOriginal().getLines();
         for (int i = 0; i < lines.size(); i++) {
             target.add(position + i, lines.get(i));
         }
@@ -64,7 +70,7 @@ public TYPE getType() {
     }
 
     @Override
-    public void verify(List<?> target) throws PatchFailedException {
+    public void verify(List<T> target) throws PatchFailedException {
         getOriginal().verify(target);
     }
 

src/main/java/difflib/Delta.java

@@ -21,22 +21,42 @@
  * Describes the delta between original and revised texts.
  * 
  * @author <a href="dm.naumenko@gmail.com">Dmitry Naumenko</a>
+ * @param T The type of the compared elements in the 'lines'.
  */
-public abstract class Delta {
-    private Chunk original;
-    private Chunk revised;
+public abstract class Delta<T> {
+	
+	/** The original chunk. */
+    private Chunk<T> original;
 
+    /** The revised chunk. */
+    private Chunk<T> revised;
+    
+    /**
+     * Specifies the type of the delta.
+     *
+     */
     public enum TYPE {
-        CHANGE, DELETE, INSERT
+    	/** A change in the original. */
+        CHANGE, 
+        /** A delete from the original. */
+        DELETE, 
+        /** An insert into the original. */
+        INSERT
     }
 
     /**
      * Construct the delta for original and revised chunks
      * 
-     * @param original chunk describes the original text
-     * @param revised chunk describes the revised text
+     * @param original Chunk describing the original text. Must not be {@code null}.
+     * @param revised Chunk describing the revised text. Must not be {@code null}.
      */
-    public Delta(Chunk original, Chunk revised) {
+    public Delta(Chunk<T> original, Chunk<T> revised) {
+    	if (original == null) {
+    		throw new IllegalArgumentException("original must not be null");
+    	}
+    	if (revised == null) {
+    		throw new IllegalArgumentException("revised must not be null");
+    	}
         this.original = original;
         this.revised = revised;
     }
@@ -47,23 +67,23 @@ public Delta(Chunk original, Chunk revised) {
      * @param target the text to patch.
      * @throws PatchFailedException if the patch cannot be applied.
      */
-    public abstract void verify(List<?> target) throws PatchFailedException;
+    public abstract void verify(List<T> target) throws PatchFailedException;
 
     /**
      * Applies this delta as the patch for a given target
      * 
      * @param target the given target
      * @throws PatchFailedException
      */
-    public abstract void applyTo(List<Object> target) throws PatchFailedException;
+    public abstract void applyTo(List<T> target) throws PatchFailedException;
 
     /**
      * Cancel this delta for a given revised text. The action is opposite to
      * patch.
      * 
      * @param target the given revised text
      */
-    public abstract void restore(List<Object> target);
+    public abstract void restore(List<T> target);
 
     /**
      * Returns the type of delta
@@ -72,38 +92,33 @@ public Delta(Chunk original, Chunk revised) {
     public abstract TYPE getType();
 
     /**
-     * @return the Chunk describing the original text
+     * @return The Chunk describing the original text.
      */
-    public Chunk getOriginal() {
+    public Chunk<T> getOriginal() {
         return original;
     }
 
     /**
-     * @param original the Chunk describing the original text to set
+     * @param original The Chunk describing the original text to set.
      */
-    public void setOriginal(Chunk original) {
+    public void setOriginal(Chunk<T> original) {
         this.original = original;
     }
 
     /**
-     * @return the Chunk describing the revised text
+     * @return The Chunk describing the revised text.
      */
-    public Chunk getRevised() {
+    public Chunk<T> getRevised() {
         return revised;
     }
 
     /**
-     * @param revised the Chunk describing the revised text to set
+     * @param revised The Chunk describing the revised text to set.
      */
-    public void setRevised(Chunk revised) {
+    public void setRevised(Chunk<T> revised) {
         this.revised = revised;
     }
 
-    /*
-     * (non-Javadoc)
-     * 
-     * @see java.lang.Object#hashCode()
-     */
     @Override
     public int hashCode() {
         final int prime = 31;
@@ -113,11 +128,6 @@ public int hashCode() {
         return result;
     }
 
-    /*
-     * (non-Javadoc)
-     * 
-     * @see java.lang.Object#equals(java.lang.Object)
-     */
     @Override
     public boolean equals(Object obj) {
         if (this == obj)
@@ -126,7 +136,7 @@ public boolean equals(Object obj) {
             return false;
         if (getClass() != obj.getClass())
             return false;
-        Delta other = (Delta) obj;
+        Delta<T> other = (Delta) obj;
         if (original == null) {
             if (other.original != null)
                 return false;

src/main/java/difflib/DeltaComparator.java

@@ -5,15 +5,16 @@
 
 /**
  * @author mksenzov
+ * @param T The type of the compared elements in the 'lines'.
  */
-public class DeltaComparator implements Comparator<Delta>, Serializable {
+public class DeltaComparator implements Comparator<Delta<?>>, Serializable {
     private static final long serialVersionUID = 1L;
-    public static final Comparator<Delta> INSTANCE = new DeltaComparator();
+    public static final Comparator<Delta<?>> INSTANCE = new DeltaComparator();
 
     private DeltaComparator() {
     }
 
-    public int compare(final Delta a, final Delta b) {
+    public int compare(final Delta<?> a, final Delta<?> b) {
         final int posA = a.getOriginal().getPosition();
         final int posB = b.getOriginal().getPosition();
         if (posA > posB) {

src/main/java/difflib/DiffAlgorithm.java

@@ -18,29 +18,30 @@
 import java.util.*;
 
 /**
- * The general interface for computing diffs between two texts
+ * The general interface for computing diffs between two lists of elements of type T. 
  * 
  * @author <a href="dm.naumenko@gmail.com">Dmitry Naumenko</a>
+ * @param T The type of the compared elements in the 'lines'.
  */
-public interface DiffAlgorithm {
+public interface DiffAlgorithm<T> {
 
     /**
      * Computes the difference between the original sequence and the revised
-     * sequence and returns it as a {@link difflib.Patch Patch} object.
+     * sequence and returns it as a {@link Patch} object.
      * 
-     * @param original the original text
-     * @param revised the revised text
-     * @return the patch
+     * @param original The original sequence. Must not be {@code null}.
+     * @param revised The revised sequence. Must not be {@code null}.
+     * @return The patch representing the diff of the given sequences. Never {@code null}.
      */
-    public Patch diff(Object[] original, Object[] revised);
+    public Patch<T> diff(T[] original, T[] revised);
 
     /**
      * Computes the difference between the original sequence and the revised
-     * sequence and returns it as a {@link difflib.Patch Patch} object.
+     * sequence and returns it as a {@link Patch} object.
      * 
-     * @param original the original text
-     * @param revised the revised text
-     * @return the patch
+     * @param original The original sequence. Must not be {@code null}.
+     * @param revised The revised sequence. Must not be {@code null}.
+     * @return The patch representing the diff of the given sequences. Never {@code null}.
      */
-    public Patch diff(List<?> original, List<?> revised);
+    public Patch<T> diff(List<T> original, List<T> revised);
 }