diff --git a/pom.xml b/pom.xml
index 20daba289..18ba9afe6 100644
--- a/pom.xml
+++ b/pom.xml
@@ -226,9 +226,6 @@
Berin Loritsch
-
- Luc Maisonobe
- Hendrik Maryns
diff --git a/src/main/java/org/apache/commons/collections/IndexedCollection.java b/src/main/java/org/apache/commons/collections/IndexedCollection.java
index f0806955e..fcda9bc9e 100644
--- a/src/main/java/org/apache/commons/collections/IndexedCollection.java
+++ b/src/main/java/org/apache/commons/collections/IndexedCollection.java
@@ -1,136 +1,136 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.collections;
-
-import java.util.Collection;
-import java.util.HashMap;
-
-import org.apache.commons.collections.collection.AbstractCollectionDecorator;
-
-/**
- * An IndexedCollection is a Map-like view onto a Collection. It accepts a
- * keyTransformer to define how the keys are converted from the values.
- *
- * Modifications made to this decorator modify the index as well as the
- * decorated {@link Collection}. However, modifications to the underlying
- * {@link Collection} will not updated the index and it will get out of sync.
- *
- * If modification to the decorated {@link Collection} is unavoidable, then a
- * call to {@link #reindex()} will update the index to the current contents of
- * the {@link Collection}.
- *
- * @param the type of object in the index.
- * @param the type of object in the collection.
- * @author Stephen Kestle
- */
-// TODO support MultiMap/non-unique index behavior
-// TODO add support for remove and clear
-public class IndexedCollection extends AbstractCollectionDecorator {
- /**
- * .
- */
- private static final long serialVersionUID = -5512610452568370038L;
-
- /**
- * Create an {@link IndexedCollection} for a unique index.
- *
- * @param the index object type.
- * @param the collection type.
- * @param coll the decorated {@link Collection}.
- * @param keyTransformer the {@link Transformer} for generating index keys.
- * @return the created {@link IndexedCollection}.
- */
- public static IndexedCollection uniqueIndexedCollection(final Collection coll, final Transformer keyTransformer) {
- return new IndexedCollection(coll, keyTransformer, new HashMap());
- }
-
- /**
- * The {@link Transformer} for generating index keys.
- */
- private final Transformer keyTransformer;
-
- /**
- * The map of indexes to collected objects.
- */
- private final HashMap index;
-
- /**
- * Create a {@link IndexedCollection} for a unique index.
- *
- * @param coll the decorated {@link Collection}.
- * @param keyTransformer the {@link Transformer} for generating index keys.
- */
- public IndexedCollection(Collection coll, Transformer keyTransformer, HashMap map) {
- super(coll);
- this.keyTransformer = keyTransformer;
- this.index = map;
- reindex();
- }
-
- /**
- * Clears the index and re-indexes the entire decorated {@link Collection}.
- */
- public void reindex() {
- index.clear();
- for (C c : decorated()) {
- addIndex(c);
- }
- }
-
- /**
- * Adds an object to the collection and index.
- */
- @Override
- // TODO: Add error handling for when super.add() fails
- public boolean add(C object) {
- addIndex(object);
- return super.add(object);
- }
-
- /**
- * Adds an entire collection to the collection and index.
- */
- @Override
- // TODO: Add error handling for when super.addAll() fails
- public boolean addAll(Collection coll) {
- for (C c : coll) {
- addIndex(c);
- }
- return super.addAll(coll);
- }
-
- /**
- * Provides checking for adding the index.
- *
- * @param object the object to index.
- */
- private void addIndex(C object) {
- final C existingObject = index.put(keyTransformer.transform(object), object);
- if (existingObject != null) {
- throw new IllegalArgumentException("Duplicate key in uniquely indexed collection.");
- }
- }
-
- /**
- * Get the element associated with the given key.
- * @param key to look up
- * @return element found
- */
- public C get(K key) {
- return index.get(key);
- }
-}
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.collections;
+
+import java.util.Collection;
+import java.util.HashMap;
+
+import org.apache.commons.collections.collection.AbstractCollectionDecorator;
+
+/**
+ * An IndexedCollection is a Map-like view onto a Collection. It accepts a
+ * keyTransformer to define how the keys are converted from the values.
+ *
+ * Modifications made to this decorator modify the index as well as the
+ * decorated {@link Collection}. However, modifications to the underlying
+ * {@link Collection} will not updated the index and it will get out of sync.
+ *
+ * If modification to the decorated {@link Collection} is unavoidable, then a
+ * call to {@link #reindex()} will update the index to the current contents of
+ * the {@link Collection}.
+ *
+ * @param the type of object in the index.
+ * @param the type of object in the collection.
+ * @author Stephen Kestle
+ */
+// TODO support MultiMap/non-unique index behavior
+// TODO add support for remove and clear
+public class IndexedCollection extends AbstractCollectionDecorator {
+ /**
+ * .
+ */
+ private static final long serialVersionUID = -5512610452568370038L;
+
+ /**
+ * Create an {@link IndexedCollection} for a unique index.
+ *
+ * @param the index object type.
+ * @param the collection type.
+ * @param coll the decorated {@link Collection}.
+ * @param keyTransformer the {@link Transformer} for generating index keys.
+ * @return the created {@link IndexedCollection}.
+ */
+ public static IndexedCollection uniqueIndexedCollection(final Collection coll, final Transformer keyTransformer) {
+ return new IndexedCollection(coll, keyTransformer, new HashMap());
+ }
+
+ /**
+ * The {@link Transformer} for generating index keys.
+ */
+ private final Transformer keyTransformer;
+
+ /**
+ * The map of indexes to collected objects.
+ */
+ private final HashMap index;
+
+ /**
+ * Create a {@link IndexedCollection} for a unique index.
+ *
+ * @param coll the decorated {@link Collection}.
+ * @param keyTransformer the {@link Transformer} for generating index keys.
+ */
+ public IndexedCollection(Collection coll, Transformer keyTransformer, HashMap map) {
+ super(coll);
+ this.keyTransformer = keyTransformer;
+ this.index = map;
+ reindex();
+ }
+
+ /**
+ * Clears the index and re-indexes the entire decorated {@link Collection}.
+ */
+ public void reindex() {
+ index.clear();
+ for (C c : decorated()) {
+ addIndex(c);
+ }
+ }
+
+ /**
+ * Adds an object to the collection and index.
+ */
+ @Override
+ // TODO: Add error handling for when super.add() fails
+ public boolean add(C object) {
+ addIndex(object);
+ return super.add(object);
+ }
+
+ /**
+ * Adds an entire collection to the collection and index.
+ */
+ @Override
+ // TODO: Add error handling for when super.addAll() fails
+ public boolean addAll(Collection coll) {
+ for (C c : coll) {
+ addIndex(c);
+ }
+ return super.addAll(coll);
+ }
+
+ /**
+ * Provides checking for adding the index.
+ *
+ * @param object the object to index.
+ */
+ private void addIndex(C object) {
+ final C existingObject = index.put(keyTransformer.transform(object), object);
+ if (existingObject != null) {
+ throw new IllegalArgumentException("Duplicate key in uniquely indexed collection.");
+ }
+ }
+
+ /**
+ * Get the element associated with the given key.
+ * @param key to look up
+ * @return element found
+ */
+ public C get(K key) {
+ return index.get(key);
+ }
+}
diff --git a/src/main/java/org/apache/commons/collections/functors/CatchAndRethrowClosure.java b/src/main/java/org/apache/commons/collections/functors/CatchAndRethrowClosure.java
index a77e91dce..d970a11f3 100644
--- a/src/main/java/org/apache/commons/collections/functors/CatchAndRethrowClosure.java
+++ b/src/main/java/org/apache/commons/collections/functors/CatchAndRethrowClosure.java
@@ -1,76 +1,76 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.collections.functors;
-
-import org.apache.commons.collections.Closure;
-import org.apache.commons.collections.FunctorException;
-
-/**
- * {@link Closure} that catches any checked exception and re-throws it as a
- * {@link FunctorException} runtime exception. Example usage:
- *
- *
- * // Create a catch and re-throw closure via anonymous subclass
- * CatchAndRethrowClosure<String> writer = new ThrowingClosure() {
- * private java.io.Writer out = // some writer
- *
- * protected void executeAndThrow(String input) throws IOException {
- * out.write(input); // throwing of IOException allowed
- * }
- * };
- *
- * // use catch and re-throw closure
- * java.util.List strList = // some list
- * try {
- * CollctionUtils.forAllDo(strList, writer);
- * } catch (FunctorException ex) {
- * Throwable originalError = ex.getCause();
- * // handle error
- * }
- *
- *
- * @since Commons Collections 4.0
- * @version $Revision$
- */
-public abstract class CatchAndRethrowClosure implements Closure {
-
- /**
- * Execute this closure on the specified input object.
- *
- * @param input the input to execute on
- * @throws FunctorException (runtime) if the closure execution resulted in a
- * checked exception.
- */
- public void execute(E input) {
- try {
- executeAndThrow(input);
- } catch (RuntimeException ex) {
- throw ex;
- } catch (Throwable t) {
- throw new FunctorException(t);
- }
- }
-
- /**
- * Execute this closure on the specified input object.
- *
- * @param input the input to execute on
- * @throws Throwable if the closure execution resulted in a checked
- * exception.
- */
- protected abstract void executeAndThrow(E input) throws Throwable;
-}
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.collections.functors;
+
+import org.apache.commons.collections.Closure;
+import org.apache.commons.collections.FunctorException;
+
+/**
+ * {@link Closure} that catches any checked exception and re-throws it as a
+ * {@link FunctorException} runtime exception. Example usage:
+ *
+ *
+ * // Create a catch and re-throw closure via anonymous subclass
+ * CatchAndRethrowClosure<String> writer = new ThrowingClosure() {
+ * private java.io.Writer out = // some writer
+ *
+ * protected void executeAndThrow(String input) throws IOException {
+ * out.write(input); // throwing of IOException allowed
+ * }
+ * };
+ *
+ * // use catch and re-throw closure
+ * java.util.List strList = // some list
+ * try {
+ * CollctionUtils.forAllDo(strList, writer);
+ * } catch (FunctorException ex) {
+ * Throwable originalError = ex.getCause();
+ * // handle error
+ * }
+ *
+ *
+ * @since Commons Collections 4.0
+ * @version $Revision$
+ */
+public abstract class CatchAndRethrowClosure implements Closure {
+
+ /**
+ * Execute this closure on the specified input object.
+ *
+ * @param input the input to execute on
+ * @throws FunctorException (runtime) if the closure execution resulted in a
+ * checked exception.
+ */
+ public void execute(E input) {
+ try {
+ executeAndThrow(input);
+ } catch (RuntimeException ex) {
+ throw ex;
+ } catch (Throwable t) {
+ throw new FunctorException(t);
+ }
+ }
+
+ /**
+ * Execute this closure on the specified input object.
+ *
+ * @param input the input to execute on
+ * @throws Throwable if the closure execution resulted in a checked
+ * exception.
+ */
+ protected abstract void executeAndThrow(E input) throws Throwable;
+}
diff --git a/src/main/java/org/apache/commons/collections/functors/ComparatorPredicate.java b/src/main/java/org/apache/commons/collections/functors/ComparatorPredicate.java
index 60bbb6b32..e88dea238 100644
--- a/src/main/java/org/apache/commons/collections/functors/ComparatorPredicate.java
+++ b/src/main/java/org/apache/commons/collections/functors/ComparatorPredicate.java
@@ -1,188 +1,188 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.collections.functors;
-
-import java.io.Serializable;
-import java.util.Comparator;
-
-import org.apache.commons.collections.Predicate;
-
-/**
- * Predicate that compares the input object with the one stored in the predicate using a comparator.
- * In addition, the comparator result can be evaluated in accordance to a supplied criterion value.
- *
- * In order to demonstrate the use of the predicate, the following variables are declared:
- *
- *
- * Integer ONE = new Integer(1);
- * Integer TWO = new Integer(2);
- *
- * Comparator comparator = new Comparator() {
- *
- * public int compare(Object first, Object second) {
- * return ((Integer) second) - ((Integer) first);
- * }
- *
- * };
- *
- *
- * Using the declared variables, the ComparatorPredicate can be used used in the
- * following way:
- *
- *
- *
- * The input variable TWO in compared to the stored variable ONE using
- * the supplied comparator. This is the default usage of the predicate and will return
- * true if the underlying comparator returns 0. In addition to the default
- * usage of the predicate, it is possible to evaluate the comparator's result in several ways. The
- * following {@link Criterion} enumeration values are provided by the predicate:
- *
- *
- *
- *
EQUAL
- *
GREATER
- *
GREATER_OR_EQUAL
- *
LESS
- *
LESS_OR_EQUAL
- *
- *
- * The following examples demonstrates how these constants can be used in order to manipulate the
- * evaluation of a comparator result.
- *
- *
- *
- * The input variable TWO is compared to the stored variable ONE using the supplied comparator
- * using the GREATER evaluation criterion constant. This instructs the predicate to
- * return true if the comparator returns a value greater than 0.
- *
- * @since Commons Collections 4.0
- * @version $Revision$
- *
- * @author Rune Peter Bjørnstad.
- */
-public class ComparatorPredicate implements Predicate, Serializable {
-
- private static final long serialVersionUID = -1863209236504077399L;
-
- public enum Criterion {
- EQUAL, GREATER, LESS, GREATER_OR_EQUAL, LESS_OR_EQUAL,
- }
-
- // Instance variables:
-
- /** The internal object to compare with */
- private final T object;
-
- /** The comparator to use for comparison */
- private final Comparator comparator;
-
- /** The comparison evaluation criterion to use */
- private final Criterion criterion;
-
- /**
- * Factory to create the comparator predicate
- *
- * @param object the object to compare to
- * @param comparator the comparator to use for comparison
- * @return the predicate
- * @throws IllegalArgumentException if comparator is null
- */
- public static Predicate comparatorPredicate(T object, Comparator comparator) {
- return comparatorPredicate(object, comparator, Criterion.EQUAL);
- }
-
- /**
- * Factory to create the comparator predicate
- *
- * @param object the object to compare to
- * @param comparator the comparator to use for comparison
- * @param criterion the criterion to use to evaluate comparison
- * @return the predicate
- * @throws IllegalArgumentException if comparator is null of criterion is invalid
- */
- public static Predicate comparatorPredicate(T object, Comparator comparator, Criterion criterion) {
- if (comparator == null) {
- throw new IllegalArgumentException("Comparator must not be null.");
- }
- if (criterion == null) {
- throw new IllegalArgumentException("Criterion must not be null.");
- }
- return new ComparatorPredicate(object, comparator, criterion);
- }
-
- /**
- * Constructor that performs no validation.
- * Use getInstance if you want.
- *
- * @param object the object to compare to
- * @param comparator the comparator to use for comparison
- * @param criterion the criterion to use to evaluate comparison
- */
- public ComparatorPredicate(T object, Comparator comparator, Criterion criterion) {
- super();
- this.object = object;
- this.comparator = comparator;
- this.criterion = criterion;
- }
-
- /**
- * Evaluates the predicate. The predicate evaluates to true in the following cases:
- *
- *
- *
- * @see org.apache.commons.collections.Predicate#evaluate(java.lang.Object)
- * @see java.util.Comparator#compare(java.lang.Object first, java.lang.Object second)
- *
- * @throws IllegalStateException if the criterion is invalid (really not possible)
- */
- public boolean evaluate(T target) {
-
- boolean result = false;
- int comparison = comparator.compare(object, target);
- switch (criterion) {
- case EQUAL:
- result = (comparison == 0);
- break;
- case GREATER:
- result = (comparison > 0);
- break;
- case LESS:
- result = (comparison < 0);
- break;
- case GREATER_OR_EQUAL:
- result = (comparison >= 0);
- break;
- case LESS_OR_EQUAL:
- result = (comparison <= 0);
- break;
- default:
- throw new IllegalStateException("The current criterion '" + criterion + "' is invalid.");
- }
-
- return result;
- }
-}
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.collections.functors;
+
+import java.io.Serializable;
+import java.util.Comparator;
+
+import org.apache.commons.collections.Predicate;
+
+/**
+ * Predicate that compares the input object with the one stored in the predicate using a comparator.
+ * In addition, the comparator result can be evaluated in accordance to a supplied criterion value.
+ *
+ * In order to demonstrate the use of the predicate, the following variables are declared:
+ *
+ *
+ * Integer ONE = new Integer(1);
+ * Integer TWO = new Integer(2);
+ *
+ * Comparator comparator = new Comparator() {
+ *
+ * public int compare(Object first, Object second) {
+ * return ((Integer) second) - ((Integer) first);
+ * }
+ *
+ * };
+ *
+ *
+ * Using the declared variables, the ComparatorPredicate can be used used in the
+ * following way:
+ *
+ *
+ *
+ * The input variable TWO in compared to the stored variable ONE using
+ * the supplied comparator. This is the default usage of the predicate and will return
+ * true if the underlying comparator returns 0. In addition to the default
+ * usage of the predicate, it is possible to evaluate the comparator's result in several ways. The
+ * following {@link Criterion} enumeration values are provided by the predicate:
+ *
+ *
+ *
+ *
EQUAL
+ *
GREATER
+ *
GREATER_OR_EQUAL
+ *
LESS
+ *
LESS_OR_EQUAL
+ *
+ *
+ * The following examples demonstrates how these constants can be used in order to manipulate the
+ * evaluation of a comparator result.
+ *
+ *
+ *
+ * The input variable TWO is compared to the stored variable ONE using the supplied comparator
+ * using the GREATER evaluation criterion constant. This instructs the predicate to
+ * return true if the comparator returns a value greater than 0.
+ *
+ * @since Commons Collections 4.0
+ * @version $Revision$
+ *
+ * @author Rune Peter Bjørnstad.
+ */
+public class ComparatorPredicate implements Predicate, Serializable {
+
+ private static final long serialVersionUID = -1863209236504077399L;
+
+ public enum Criterion {
+ EQUAL, GREATER, LESS, GREATER_OR_EQUAL, LESS_OR_EQUAL,
+ }
+
+ // Instance variables:
+
+ /** The internal object to compare with */
+ private final T object;
+
+ /** The comparator to use for comparison */
+ private final Comparator comparator;
+
+ /** The comparison evaluation criterion to use */
+ private final Criterion criterion;
+
+ /**
+ * Factory to create the comparator predicate
+ *
+ * @param object the object to compare to
+ * @param comparator the comparator to use for comparison
+ * @return the predicate
+ * @throws IllegalArgumentException if comparator is null
+ */
+ public static Predicate comparatorPredicate(T object, Comparator comparator) {
+ return comparatorPredicate(object, comparator, Criterion.EQUAL);
+ }
+
+ /**
+ * Factory to create the comparator predicate
+ *
+ * @param object the object to compare to
+ * @param comparator the comparator to use for comparison
+ * @param criterion the criterion to use to evaluate comparison
+ * @return the predicate
+ * @throws IllegalArgumentException if comparator is null of criterion is invalid
+ */
+ public static Predicate comparatorPredicate(T object, Comparator comparator, Criterion criterion) {
+ if (comparator == null) {
+ throw new IllegalArgumentException("Comparator must not be null.");
+ }
+ if (criterion == null) {
+ throw new IllegalArgumentException("Criterion must not be null.");
+ }
+ return new ComparatorPredicate(object, comparator, criterion);
+ }
+
+ /**
+ * Constructor that performs no validation.
+ * Use getInstance if you want.
+ *
+ * @param object the object to compare to
+ * @param comparator the comparator to use for comparison
+ * @param criterion the criterion to use to evaluate comparison
+ */
+ public ComparatorPredicate(T object, Comparator comparator, Criterion criterion) {
+ super();
+ this.object = object;
+ this.comparator = comparator;
+ this.criterion = criterion;
+ }
+
+ /**
+ * Evaluates the predicate. The predicate evaluates to true in the following cases:
+ *
+ *
+ *
+ * @see org.apache.commons.collections.Predicate#evaluate(java.lang.Object)
+ * @see java.util.Comparator#compare(java.lang.Object first, java.lang.Object second)
+ *
+ * @throws IllegalStateException if the criterion is invalid (really not possible)
+ */
+ public boolean evaluate(T target) {
+
+ boolean result = false;
+ int comparison = comparator.compare(object, target);
+ switch (criterion) {
+ case EQUAL:
+ result = (comparison == 0);
+ break;
+ case GREATER:
+ result = (comparison > 0);
+ break;
+ case LESS:
+ result = (comparison < 0);
+ break;
+ case GREATER_OR_EQUAL:
+ result = (comparison >= 0);
+ break;
+ case LESS_OR_EQUAL:
+ result = (comparison <= 0);
+ break;
+ default:
+ throw new IllegalStateException("The current criterion '" + criterion + "' is invalid.");
+ }
+
+ return result;
+ }
+}
diff --git a/src/main/java/org/apache/commons/collections/list/difference/CommandVisitor.java b/src/main/java/org/apache/commons/collections/list/difference/CommandVisitor.java
deleted file mode 100644
index 033a02409..000000000
--- a/src/main/java/org/apache/commons/collections/list/difference/CommandVisitor.java
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.collections.list.difference;
-
-
-/** This interface should be implemented by user object to walk
- * through {@link EditScript EditScript} objects.
-
- *
Users should implement this interface in order to walk through
- * the {@link EditScript EditScript} object created by the comparison
- * of two sequences. This is a direct application of the visitor
- * design pattern. The {@link EditScript#visit EditScript.visit}
- * method takes an object implementing this interface as an argument,
- * it will perform the loop over all commands in the script and the
- * proper methods of the user class will be called as the commands are
- * encountered.
-
- *
The implementation of the user visitor class will depend on the
- * need. Here are two examples.
- *
- *
- *
- * The first example is a visitor that build the longest common
- * subsequence:
- *
- *
-
- * @since 4.0
- * @author Jordane Sarda
- * @author Luc Maisonobe
- * @version $Id$
-
- */
-public interface CommandVisitor {
-
- /** Method called when an insert command is encountered.
- * @param object object to insert (this object comes from the
- * second sequence)
- */
- void visitInsertCommand(T object);
-
- /** Method called when a keep command is encountered.
- * @param object object to keep (this object comes from the
- * first sequence)
- */
- void visitKeepCommand(T object);
-
- /** Method called when a delete command is encountered.
- * @param object object to delete (this object comes from the
- * first sequence)
- */
- void visitDeleteCommand(T object);
-
-}
diff --git a/src/main/java/org/apache/commons/collections/list/difference/DeleteCommand.java b/src/main/java/org/apache/commons/collections/list/difference/DeleteCommand.java
deleted file mode 100644
index 80e466cb9..000000000
--- a/src/main/java/org/apache/commons/collections/list/difference/DeleteCommand.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.collections.list.difference;
-
-
-/** Command representing the deletion of one object of the first sequence.
-
- * When one object of the first sequence has no corresponding object
- * in the second sequence at the right place, the {@link EditScript
- * edit script} transforming the first sequence into the second
- * sequence uses an instance of this class to represent the deletion
- * of this object. The objects embedded in these type of commands
- * always come from the first sequence.
-
- * @see SequencesComparator
- * @see EditScript
-
- * @since 4.0
- * @author Jordane Sarda
- * @author Luc Maisonobe
- * @version $Id$
- */
-public class DeleteCommand extends EditCommand {
-
- /** Simple constructor.
- * Creates a new instance of DeleteCommand
- * @param object the object of the first sequence that should be deleted
- */
- public DeleteCommand(T object) {
- super(object);
- }
-
- /** Accept a visitor.
- * When a DeleteCommand accepts a visitor, it calls
- * its {@link CommandVisitor#visitDeleteCommand
- * visitDeleteCommand} method.
- * @param visitor the visitor to be accepted
- */
- public void accept(CommandVisitor visitor) {
- visitor.visitDeleteCommand(object);
- }
-}
diff --git a/src/main/java/org/apache/commons/collections/list/difference/EditCommand.java b/src/main/java/org/apache/commons/collections/list/difference/EditCommand.java
deleted file mode 100644
index ef3d7ba43..000000000
--- a/src/main/java/org/apache/commons/collections/list/difference/EditCommand.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.collections.list.difference;
-
-
-/** Abstract base class for all commands used to transform an objects
- * sequence into another one.
-
- *
When two objects sequences are compared through the {@link
- * SequencesComparator#getScript SequencesComparator.getScript}
- * method, the result is provided has a {@link EditScript script}
- * containing the commands that progressively transform the first
- * sequence into the second one.
-
- *
There are only three types of commands, all of which are
- * subclasses of this abstract class. Each command is associated with
- * one object belonging to at least one of the sequences. These
- * commands are {@link InsertCommand InsertCommand} which correspond
- * to an object of the second sequence beeing inserted into the first
- * sequence, {@link DeleteCommand DeleteCommand} which correspond to
- * an object of the first sequence beeing removed and {@link
- * KeepCommand KeepCommand} which correspond to an object of the first
- * sequence which equals an object in the second
- * sequence. It is guaranteed that comparison is always performed this
- * way (i.e. the equals method of the object from the
- * first sequence is used and the object passed as an argument comes
- * from the second sequence) ; this can be important if subclassing is
- * used for some elements in the first sequence and the
- * equals method is specialized.
-
- * @see SequencesComparator
- * @see EditScript
-
- * @since 4.0
- * @author Jordane Sarda
- * @author Luc Maisonobe
- * @version $Id$
- */
-public abstract class EditCommand {
-
- /** Simple constructor.
- * Creates a new instance of EditCommand
- * @param object reference to the object associated with this
- * command, this refers to an element of one of the sequences
- * beeing compared
- */
- protected EditCommand(T object) {
- this.object = object;
- }
-
- /** Accept a visitor.
- * This method is invoked for each commands belonging to an {@link
- * EditScript EditScript}, in order to implement the visitor
- * design pattern
- * @param visitor the visitor to be accepted
- */
- public abstract void accept(CommandVisitor visitor);
-
- /** Object on which the command should be applied. */
- protected T object;
-
-}
diff --git a/src/main/java/org/apache/commons/collections/list/difference/EditScript.java b/src/main/java/org/apache/commons/collections/list/difference/EditScript.java
deleted file mode 100644
index d4c475172..000000000
--- a/src/main/java/org/apache/commons/collections/list/difference/EditScript.java
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.collections.list.difference;
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * This class gathers all the {@link EditCommand commands} needed to
- * transform one objects sequence into another objects sequence.
-
- *
An edit script is the most general view of the differences
- * between two sequences. It is built as the result of the comparison
- * between two sequences by the {@link SequencesComparator
- * SequencesComparator} class. The user can walk through it using
- * the visitor design pattern.
-
- *
It is guaranteed that the objects embedded in the {@link
- * InsertCommand insert commands} come from the second sequence and
- * that the objects embedded in either the {@link DeleteCommand delete
- * commands} or {@link KeepCommand keep commands} come from the first
- * sequence. This can be important if subclassing is used for some
- * elements in the first sequence and the equals method
- * is specialized.
-
- * @see SequencesComparator
- * @see EditCommand
- * @see CommandVisitor
- * @see ReplacementsHandler
- *
- * @since 4.0
- * @author Jordane Sarda
- * @author Luc Maisonobe
- * @version $Id$
- */
-public class EditScript {
-
- /** Container for the commands. */
- private List> commands;
-
- /** Length of the longest common subsequence. */
- private int lcsLength;
-
- /** Number of modifications. */
- private int modifications;
-
- /** Simple constructor.
- * Creates a new empty script.
- */
- public EditScript() {
- commands = new ArrayList>();
- lcsLength = 0;
- modifications = 0;
- }
-
- /** Add a keep command to the script.
- * @param command command to add
- */
- public void append(KeepCommand command) {
- commands.add(command);
- ++lcsLength;
- }
-
- /** Add an insert command to the script.
- * @param command command to add
- */
- public void append(InsertCommand command) {
- commands.add(command);
- ++modifications;
- }
-
- /** Add a delete command to the script.
- * @param command command to add
- */
- public void append(DeleteCommand command) {
- commands.add(command);
- ++modifications;
- }
-
- /** Visit the script.
- * The script implements the visitor design pattern, this
- * method is the entry point to which the user supplies its own
- * visitor, the script will be responsible to drive it through the
- * commands in order and call the appropriate method as each
- * command is encountered.
- * @param visitor the visitor that will visit all commands in turn
- */
- public void visit(CommandVisitor visitor) {
- for (EditCommand command : commands) {
- command.accept(visitor);
- }
- }
-
- /** Get the length of the Longest Common Subsequence (LCS).
- * The length of the longest common subsequence is the number of
- * {@link KeepCommand keep commands} in the script.
- * @return length of the Longest Common Subsequence
- */
- public int getLCSLength() {
- return lcsLength;
- }
-
- /** Get the number of effective modifications.
- * The number of effective modification is the number of {@link
- * DeleteCommand delete} and {@link InsertCommand insert} commands
- * in the script.
- * @return number of effective modifications
- */
- public int getModifications() {
- return modifications;
- }
-
-}
diff --git a/src/main/java/org/apache/commons/collections/list/difference/InsertCommand.java b/src/main/java/org/apache/commons/collections/list/difference/InsertCommand.java
deleted file mode 100644
index ccf23dfca..000000000
--- a/src/main/java/org/apache/commons/collections/list/difference/InsertCommand.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.collections.list.difference;
-
-
-/** Command representing the insertion of one object of the second sequence.
-
- * When one object of the second sequence has no corresponding object
- * in the first sequence at the right place, the {@link EditScript
- * edit script} transforming the first sequence into the second
- * sequence uses an instance of this class to represent the insertion
- * of this object. The objects embedded in these type of commands
- * always come from the second sequence.
-
- * @see SequencesComparator
- * @see EditScript
-
- * @since 4.0
- * @author Jordane Sarda
- * @author Luc Maisonobe
- * @version $Id$
- */
-public class InsertCommand extends EditCommand {
-
- /** Simple constructor.
- * Creates a new instance of InsertCommand
- * @param object the object of the second sequence that should be inserted
- */
- public InsertCommand(T object) {
- super(object);
- }
-
- /** Accept a visitor.
- * When an InsertCommand accepts a visitor, it calls
- * its {@link CommandVisitor#visitInsertCommand
- * visitInsertCommand} method.
- * @param visitor the visitor to be accepted
- */
- public void accept(CommandVisitor visitor) {
- visitor.visitInsertCommand(object);
- }
-
-}
diff --git a/src/main/java/org/apache/commons/collections/list/difference/KeepCommand.java b/src/main/java/org/apache/commons/collections/list/difference/KeepCommand.java
deleted file mode 100644
index 7364b44bc..000000000
--- a/src/main/java/org/apache/commons/collections/list/difference/KeepCommand.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.collections.list.difference;
-
-
-/** Command representing the keeping of one object present in both sequences.
-
- * When one object of the first sequence equals another
- * objects in the second sequence at the right place, the {@link
- * EditScript edit script} transforming the first sequence into the
- * second sequence uses an instance of this class to represent the
- * keeping of this object. The objects embedded in these type of
- * commands always come from the first sequence.
-
- * @see SequencesComparator
- * @see EditScript
-
- * @since 4.0
- * @author Jordane Sarda
- * @author Luc Maisonobe
- * @version $Id$
- */
-public class KeepCommand extends EditCommand {
-
- /** Simple constructor.
- * Creates a new instance of KeepCommand
- * @param object the object belonging to both sequences (the
- * object is a reference to the instance in the first sequence
- * which is known to be equal to an instance in the second
- * sequence)
- */
- public KeepCommand(T object) {
- super(object);
- }
-
- /** Accept a visitor.
- * When a KeepCommand accepts a visitor, it calls
- * its {@link CommandVisitor#visitKeepCommand visitKeepCommand} method.
- * @param visitor the visitor to be accepted
- */
- public void accept(CommandVisitor visitor) {
- visitor.visitKeepCommand(object);
- }
-}
diff --git a/src/main/java/org/apache/commons/collections/list/difference/ReplacementsFinder.java b/src/main/java/org/apache/commons/collections/list/difference/ReplacementsFinder.java
deleted file mode 100644
index ec0de8fc9..000000000
--- a/src/main/java/org/apache/commons/collections/list/difference/ReplacementsFinder.java
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.collections.list.difference;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * This class handles sequences of replacements resulting from a
- * comparison.
-
- *
The comparison of two objects sequences leads to the
- * identification of common parts and parts which only belong to the
- * first or to the second sequence. The common parts appear in the
- * edit script in the form of keep commands, they can be considered
- * as synchronization objects between the two sequences. These
- * synchronization objects split the two sequences in synchronized
- * sub-sequences. The first sequence can be transformed into the second
- * one by replacing each synchronized sub-sequence of the first
- * sequence by the corresponding sub-sequence of the second
- * sequence. This is a synthetic way to see an {@link EditScript edit
- * script}, replacing individual {@link DeleteCommand delete}, {@link
- * KeepCommand keep} and {@link InsertCommand insert} commands by
- * fewer replacements acting on complete sub-sequences.
-
- *
This class is devoted to perform this interpretation. It visits
- * an {@link EditScript edit script} (because it implements the {@link
- * CommandVisitor CommandVisitor} interface) and calls a user-supplied
- * handler implementing the {@link ReplacementsHandler
- * ReplacementsHandler} interface to process the sub-sequences.
-
- * @see ReplacementsHandler
- * @see EditScript
- * @see SequencesComparator
-
- * @since 4.0
- * @author Luc Maisonobe
- * @author Jordane Sarda
- * @version $Id$
- */
-public class ReplacementsFinder implements CommandVisitor {
-
- private List pendingInsertions;
- private List pendingDeletions;
- private int skipped;
-
- /** Handler to call when synchronized sequences are found. */
- private ReplacementsHandler handler;
-
- /** Simple constructor.
- * Creates a new instance of ReplacementsFinder
- * @param handler handler to call when synchronized sequences are
- * found
- */
- public ReplacementsFinder(ReplacementsHandler handler) {
- pendingInsertions = new ArrayList();
- pendingDeletions = new ArrayList();
- skipped = 0;
- this.handler = handler;
- }
-
- /** Add an object to the pending insertions set.
- * @param object object to insert
- */
- public void visitInsertCommand(T object) {
- pendingInsertions.add(object);
- }
-
- /** Handle a synchronization object.
- *
When a synchronization object is identified, the pending
- * insertions and pending deletions sets are provided to the user
- * handler as subsequences.
- * @param object synchronization object detected
- */
- public void visitKeepCommand(T object) {
- if (pendingDeletions.isEmpty() && pendingInsertions.isEmpty()) {
- ++skipped;
- } else {
- handler.handleReplacement(skipped, pendingDeletions, pendingInsertions);
- pendingDeletions.clear();
- pendingInsertions.clear();
- skipped = 1;
- }
- }
-
- /** Add an object to the pending deletions set.
- * @param object object to delete
- */
- public void visitDeleteCommand(T object) {
- pendingDeletions.add(object);
- }
-
-}
diff --git a/src/main/java/org/apache/commons/collections/list/difference/ReplacementsHandler.java b/src/main/java/org/apache/commons/collections/list/difference/ReplacementsHandler.java
deleted file mode 100644
index c2615a477..000000000
--- a/src/main/java/org/apache/commons/collections/list/difference/ReplacementsHandler.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.collections.list.difference;
-
-import java.util.List;
-
-/** This interface is devoted to handle synchronized replacement sequences.
- * @see ReplacementsFinder
- * @since 4.0
- * @author Luc Maisonobe
- * @version $Id$
- */
-public interface ReplacementsHandler {
-
- /** Handle two synchronized sequences.
- *
This method is called by a {@link ReplacementsFinder
- * ReplacementsFinder} instance when it has synchronized two
- * sub-sequences of object arrays being compared, and at least one
- * of the sequences is non-empty. Since the sequences are
- * synchronized, the objects before the two sub-sequences are equals
- * (if they exist). This property also holds for the objects after the
- * two sub-sequences.
- *
The replacement is defined as replacing the from
- * sub-sequence into the to sub-sequence.
- * @param skipped number of tokens skipped since the last call (i.e.
- * number of tokens that were in both sequences), this number should
- * be strictly positive except on the very first call where it can be
- * zero (if the first object of the two sequences are different)
- * @param from sub-sequence of objects coming from the first sequence
- * @param to sub-sequence of objects coming from the second sequence
- */
- public void handleReplacement(int skipped, List from, List to);
-
-}
diff --git a/src/main/java/org/apache/commons/collections/list/difference/SequencesComparator.java b/src/main/java/org/apache/commons/collections/list/difference/SequencesComparator.java
deleted file mode 100644
index 93c5cd1d2..000000000
--- a/src/main/java/org/apache/commons/collections/list/difference/SequencesComparator.java
+++ /dev/null
@@ -1,265 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.collections.list.difference;
-
-import java.util.List;
-
-
-/**
-
- * This class allows to compare two objects sequences.
-
- *
The two sequences can hold any object type, as only the
- * equals method is used to compare the elements of the
- * sequences. It is guaranteed that the comparisons will always be
- * done as o1.equals(o2) where o1 belongs to
- * the first sequence and o2 belongs to the second
- * sequence. This can be important if subclassing is used for some
- * elements in the first sequence and the equals method
- * is specialized.
-
- *
Comparison can be seen from two points of view: either as
- * giving the smallest modification allowing to transform the first
- * sequence into the second one, or as giving the longest sequence
- * which is a subsequence of both initial sequences. The
- * equals method is used to compare objects, so any
- * object can be put into sequences. Modifications include deleting,
- * inserting or keeping one object, starting from the beginning of the
- * first sequence.
-
- *
This class implements the comparison algorithm, which is the
- * very efficient algorithm from Eugene W. Myers An
- * O(ND) Difference Algorithm and Its Variations. This algorithm
- * produces the shortest possible {@link
- * org.apache.commons.collections.list.difference.EditScript edit script}
- * containing all the {@link
- * org.apache.commons.collections.list.difference.EditCommand commands} needed to
- * transform the first sequence into the second one.
It is guaranteed that the comparisons will always be
- * done as o1.equals(o2) where o1 belongs
- * to the first sequence and o2 belongs to the second
- * sequence. This can be important if subclassing is used for some
- * elements in the first sequence and the equals method
- * is specialized.
- * @param sequence1 first sequence to be compared
- * @param sequence2 second sequence to be compared
- */
- public SequencesComparator(List sequence1, List sequence2) {
- this.sequence1 = sequence1;
- this.sequence2 = sequence2;
-
- int size = sequence1.size() + sequence2.size() + 2;
- vDown = new int[size];
- vUp = new int[size];
-
- }
-
- /** Build a snake.
- * @param start the value of the start of the snake
- * @param diag the value of the diagonal of the snake
- * @param end1 the value of the end of the first sequence to be compared
- * @param end2 the value of the end of the second sequence to be compared
- * @return the snake built
- */
- private Snake buildSnake(int start, int diag, int end1, int end2) {
- int end = start;
- while (((end - diag) < end2)
- && (end < end1)
- && sequence1.get(end).equals(sequence2.get(end - diag))) {
- ++end;
- }
- return new Snake(start, end, diag);
- }
-
- /** Get the middle snake corresponding to two subsequences of the
- * main sequences.
- * The snake is found using the MYERS Algorithm (this algorithms has
- * also been implemented in the GNU diff program). This algorithm is
- * explained in Eugene Myers article: An
- * O(ND) Difference Algorithm and Its Variations.
- * @param start1 the begin of the first sequence to be compared
- * @param end1 the end of the first sequence to be compared
- * @param start2 the begin of the second sequence to be compared
- * @param end2 the end of the second sequence to be compared
- * @return the middle snake
- */
- private Snake getMiddleSnake(int start1, int end1, int start2, int end2) {
- // Myers Algorithm
- //Initialisations
- int m = end1 - start1;
- int n = end2 - start2;
- if ((m == 0) || (n == 0)) {
- return null;
- }
-
- int delta = m - n;
- int sum = n + m;
- int offset = ((sum % 2 == 0) ? sum : (sum + 1)) / 2;
- vDown[1+offset] = start1;
- vUp[1+offset] = end1 + 1;
-
- for (int d = 0; d <= offset ; ++d) {
- // Down
- for (int k = -d; k <= d; k += 2) {
- // First step
-
- int i = k + offset;
- if ((k == -d) || ((k != d) && (vDown[i-1] < vDown[i+1]))) {
- vDown[i] = vDown[i+1];
- } else {
- vDown[i] = vDown[i-1] + 1;
- }
-
- int x = vDown[i];
- int y = x - start1 + start2 - k;
-
- while ((x < end1) && (y < end2) && (sequence1.get(x).equals(sequence2.get(y)))) {
- vDown[i] = ++x;
- ++y;
- }
- // Second step
- if (((delta % 2) != 0 ) && ((delta - d) <= k) && (k <= (delta + d))) {
- if (vUp[i-delta] <= vDown[i]) {
- return buildSnake(vUp[i-delta], k + start1 - start2, end1, end2);
- }
- }
- }
-
- // Up
- for (int k = (delta - d); k <= (delta + d); k += 2) {
- // First step
- int i = k + offset - delta;
- if ((k == (delta - d))
- || ((k != (delta + d)) && (vUp[i+1] <= vUp[i-1]))) {
- vUp[i] = vUp[i+1] - 1;
- } else {
- vUp[i] = vUp[i-1];
- }
-
- int x = vUp[i] - 1;
- int y = x - start1 + start2 - k;
- while ((x >= start1) && (y >= start2)
- && sequence1.get(x).equals(sequence2.get(y))) {
- vUp[i] = x--;
- y--;
- }
- // Second step
- if (((delta % 2) == 0) && (-d <= k) && (k <= d) ) {
- if (vUp[i] <= vDown[i + delta]) {
- return buildSnake(vUp[i], k + start1 - start2, end1, end2);
- }
- }
- }
- }
-
- // this should not happen
- throw new RuntimeException("Internal Error");
-
- }
-
-
- /** Build an edit script.
- * @param start1 the begin of the first sequence to be compared
- * @param end1 the end of the first sequence to be compared
- * @param start2 the begin of the second sequence to be compared
- * @param end2 the end of the second sequence to be compared
- * @param script the edited script
- */
- private void buildScript(int start1, int end1, int start2, int end2,
- EditScript script) {
-
- Snake middle = getMiddleSnake(start1, end1, start2, end2);
-
- if ((middle == null)
- || ((middle.getStart() == end1) && (middle.getDiag() == (end1 - end2)))
- || ((middle.getEnd() == start1) && (middle.getDiag() == (start1 - start2)))) {
-
- int i = start1;
- int j = start2;
- while ((i < end1) || (j < end2)) {
- if ((i < end1) && (j < end2) && sequence1.get(i).equals(sequence2.get(j))) {
- script.append(new KeepCommand(sequence1.get(i)));
- ++i;
- ++j;
- } else {
- if ((end1 - start1) > (end2 - start2)) {
- script.append(new DeleteCommand(sequence1.get(i)));
- ++i;
- } else {
- script.append(new InsertCommand(sequence2.get(j)));
- ++j;
- }
- }
- }
-
- } else {
-
- buildScript(start1, middle.getStart(),
- start2, middle.getStart() - middle.getDiag(),
- script);
- for (int i = middle.getStart(); i < middle.getEnd(); ++i) {
- script.append(new KeepCommand(sequence1.get(i)));
- }
- buildScript(middle.getEnd(), end1,
- middle.getEnd() - middle.getDiag(), end2,
- script);
- }
- }
-
- /** Get the edit script script.
- *
It is guaranteed that the objects embedded in the {@link
- * InsertCommand insert commands} come from the second sequence and
- * that the objects embedded in either the {@link DeleteCommand
- * delete commands} or {@link KeepCommand keep commands} come from
- * the first sequence. This can be important if subclassing is used
- * for some elements in the first sequence and the
- * equals method is specialized.
- * @return the edit script resulting from the comparison of the two
- * sequences
- */
- public EditScript getScript() {
- EditScript script = new EditScript();
- buildScript(0, sequence1.size(), 0, sequence2.size(), script);
- return script;
- }
-
-}
diff --git a/src/main/java/org/apache/commons/collections/list/difference/Snake.java b/src/main/java/org/apache/commons/collections/list/difference/Snake.java
deleted file mode 100644
index c0b9736b1..000000000
--- a/src/main/java/org/apache/commons/collections/list/difference/Snake.java
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.collections.list.difference;
-
-/**
- * This class is a simple placeholder to hold the end part of a path
- * under construction in a {@link SequencesComparator
- * SequencesComparator}.
-
- *
-
- * @since 4.0
- * @author Jordane Sarda
- * @version $Id$
- */
- public class Snake {
-
- /** Start index. */
- private int start;
-
- /** End index. */
- private int end;
-
- /** Diagonal number. */
- private int diag;
-
- /** Simple constructor.
- * Creates a new instance of Snake with default indices
- */
- public Snake() {
- start = -1;
- end = -1;
- diag = 0;
- }
-
- /** Simple constructor.
- * Creates a new instance of Snake with specified indices
- * @param start start index of the snake
- * @param end end index of the snake
- * @param diag diagonal number
- */
- public Snake(int start, int end, int diag) {
- this.start = start;
- this.end = end;
- this.diag = diag;
- }
-
- /** Get the start index of the snake.
- * @return start index of the snake
- */
- public int getStart() {
- return start;
- }
-
- /** Get the end index of the snake.
- * @return end index of the snake
- */
- public int getEnd() {
- return end;
- }
-
- /** Get the diagonal number of the snake.
- * @return diagonal number of the snake
- */
- public int getDiag() {
- return diag;
- }
-
-}
diff --git a/src/main/java/org/apache/commons/collections/list/difference/package.html b/src/main/java/org/apache/commons/collections/list/difference/package.html
deleted file mode 100644
index 5314e8564..000000000
--- a/src/main/java/org/apache/commons/collections/list/difference/package.html
+++ /dev/null
@@ -1,93 +0,0 @@
-
-
-
-This package provides classes to compare two objects sequences.
-
-
-The two sequences can hold any object type, as only the
-equals method is used to compare the elements of the
-sequences. It is guaranteed that the comparisons will always be done
-as o1.equals(o2) where o1 belongs to the
-first sequence and o2 belongs to the second
-sequence. This can be important if subclassing is used for some
-elements in the first sequence and the equals method is
-specialized.
-
-
-
-Comparison can be seen from two points of view: either as giving the
-smallest modification allowing to transform the first sequence into
-the second one, or as giving the longest sequence which is a
-subsequence of both initial sequences. The equals method
-is used to compare objects, so any object can be put into
-sequences. Modifications include deleting, inserting or keeping one
-object, starting from the beginning of the first sequence. Like most
-algorithms of the same type, objects transpositions are not
-supported. This means that if a sequence (A, B) is
-compared to (B, A), the result will be either the
-sequence of three commands delete A, keep B,
-insert A or the sequence insert B,
-keep A, delete B.
-
-
-
-The package uses a very efficient comparison algorithm designed by
-Eugene W. Myers and described in his paper: An O(ND)
-Difference Algorithm and Its Variations. This algorithm produces
-the shortest possible {@link
-org.apache.commons.collections.list.difference.EditScript edit script} containing
-all the {@link org.apache.commons.collections.list.difference.EditCommand
-commands} needed to transform the first sequence into the second
-one. The entry point for the user to this algorithm is the {@link
-org.apache.commons.collections.list.difference.SequencesComparator
-SequencesComparator} class.
-
-
-
-As explained in Gene Myers paper, the edit script is equivalent to all
-other representations and contains all the needed information either
-to perform the transformation, of course, or to retrieve the longest
-common subsequence for example.
-
-
-
-If the user needs a very fine grained access to the comparison result,
-he needs to go through this script by providing a visitor implementing
-the {@link org.apache.commons.collections.list.difference.CommandVisitor
-CommandVisitor} interface.
-
-
-
-Sometimes however, a more synthetic approach is needed. If the user
-prefers to see the differences between the two sequences as global
-replacement operations acting on complete subsequences of
-the original sequences, he will provide an object implementing the
-simple {@link org.apache.commons.collections.list.difference.ReplacementsHandler
-ReplacementsHandler} interface, using an instance of the {@link
-org.apache.commons.collections.list.difference.ReplacementsFinder
-ReplacementsFinder} class as a command converting layer between his
-object and the edit script. The number of objects which are common to
-both initial arrays and hence are skipped between each call to the user
-{@link
-org.apache.commons.collections.list.difference.ReplacementsHandler#handleReplacement
-handleReplacement} method is also provided. This allows the user to keep
-track of the current index in both arrays if he needs so.
-
-
-
diff --git a/src/test/java/org/apache/commons/collections/AbstractDecoratedCollectionTest.java b/src/test/java/org/apache/commons/collections/AbstractDecoratedCollectionTest.java
index f7a1441b8..4d3a2588d 100644
--- a/src/test/java/org/apache/commons/collections/AbstractDecoratedCollectionTest.java
+++ b/src/test/java/org/apache/commons/collections/AbstractDecoratedCollectionTest.java
@@ -1,38 +1,38 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.collections;
-
-import java.util.ArrayList;
-import java.util.Collection;
-
-import org.junit.Before;
-
-public abstract class AbstractDecoratedCollectionTest {
- /**
- * The {@link Collection} being decorated.
- */
- protected Collection original;
- /**
- * The Collection under test that decorates {@link #original}.
- */
- protected Collection decorated;
-
- @Before
- public void setUpDecoratedCollection() throws Exception {
- original = new ArrayList();
- }
-}
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.collections;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import org.junit.Before;
+
+public abstract class AbstractDecoratedCollectionTest {
+ /**
+ * The {@link Collection} being decorated.
+ */
+ protected Collection original;
+ /**
+ * The Collection under test that decorates {@link #original}.
+ */
+ protected Collection decorated;
+
+ @Before
+ public void setUpDecoratedCollection() throws Exception {
+ original = new ArrayList();
+ }
+}
diff --git a/src/test/java/org/apache/commons/collections/MockTestCase.java b/src/test/java/org/apache/commons/collections/MockTestCase.java
index 6dfb14694..21ea8bfdc 100644
--- a/src/test/java/org/apache/commons/collections/MockTestCase.java
+++ b/src/test/java/org/apache/commons/collections/MockTestCase.java
@@ -1,67 +1,67 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.collections;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.ListIterator;
-
-import org.easymock.EasyMock;
-import org.easymock.IExpectationSetters;
-
-/**
- * Provides utilities for making mock-based tests. Most notable is the generic "type-safe"
- * {@link #createMock(Class)} method, and {@link #replay()} and {@link #verify()} methods
- * that call the respective methods on all created mock objects.
- *
- * @author Stephen Kestle
- */
-public abstract class MockTestCase {
- private List