IN PROGRESS - BATCH-709: Change all collections to use generics

spring-batch-infrastructure/src/main/java/org/springframework/batch/repeat/support/JdkConcurrentResultQueue.java

@@ -28,13 +28,13 @@ import java.util.concurrent.Semaphore;
 class JdkConcurrentResultQueue extends AbstractResultQueue implements RepeatInternalState {
 
 	// Accumulation of result objects as they finish.
-	private final BlockingQueue results;
+	private final BlockingQueue<ResultHolder> results;
 
 	// Accumulation of dummy objects flagging expected results in the future.
 	private final Semaphore waits;
 
 	JdkConcurrentResultQueue(int throttleLimit) {
-		results = new LinkedBlockingQueue();
+		results = new LinkedBlockingQueue<ResultHolder>();
 		waits = new Semaphore(throttleLimit);
 	}
 

spring-batch-infrastructure/src/main/java/org/springframework/batch/repeat/support/RepeatInternalState.java

@@ -20,6 +20,6 @@ import java.util.Collection;
 
 public interface RepeatInternalState {
 
-	Collection getThrowables();
+	Collection<Throwable> getThrowables();
 
 }

spring-batch-infrastructure/src/main/java/org/springframework/batch/repeat/support/RepeatInternalStateSupport.java

@@ -23,12 +23,12 @@ import java.util.Set;
 public class RepeatInternalStateSupport implements RepeatInternalState {
 	
 	// Accumulation of failed results. 
-	Set throwables = new HashSet();
+	private Set<Throwable> throwables = new HashSet<Throwable>();
 	
 	/* (non-Javadoc)
 	 * @see org.springframework.batch.repeat.support.BatchInternalState#getThrowables()
 	 */
-	public Collection getThrowables() {
+	public Collection<Throwable> getThrowables() {
 		return throwables;
 	}
 

spring-batch-infrastructure/src/main/java/org/springframework/batch/repeat/support/RepeatSynchronizationManager.java

@@ -35,7 +35,7 @@ import org.springframework.batch.repeat.RepeatOperations;
  */
 public class RepeatSynchronizationManager {
 
-	private static final ThreadLocal contextHolder = new ThreadLocal();
+	private static final ThreadLocal<RepeatContext> contextHolder = new ThreadLocal<RepeatContext>();
 
 	private RepeatSynchronizationManager() {
 	}
@@ -50,7 +50,7 @@ public class RepeatSynchronizationManager {
 	 * are not in a batch).
 	 */
 	public static RepeatContext getContext() {
-		return (RepeatContext) contextHolder.get();
+		return contextHolder.get();
 	}
 
 	/**

spring-batch-infrastructure/src/main/java/org/springframework/batch/repeat/support/RepeatTemplate.java

@@ -88,7 +88,7 @@ public class RepeatTemplate implements RepeatOperations {
 	 * @param listener
 	 */
 	public void registerListener(RepeatListener listener) {
-		List list = new ArrayList(Arrays.asList(listeners));
+		List<RepeatListener> list = new ArrayList<RepeatListener>(Arrays.asList(listeners));
 		list.add(listener);
 		listeners = (RepeatListener[]) list.toArray(new RepeatListener[list.size()]);
 	}
@@ -183,7 +183,7 @@ public class RepeatTemplate implements RepeatOperations {
 		ExitStatus result = ExitStatus.CONTINUABLE;
 
 		RepeatInternalState state = createInternalState(context);
-		Collection throwables = state.getThrowables();
+		Collection<Throwable> throwables = state.getThrowables();
 
 		try {
 

spring-batch-infrastructure/src/main/java/org/springframework/batch/retry/policy/AbstractStatefulRetryPolicy.java

@@ -17,7 +17,6 @@
 package org.springframework.batch.retry.policy;
 
 import java.util.HashSet;
-import java.util.Iterator;
 import java.util.Set;
 
 import org.springframework.batch.retry.ExhaustedRetryException;
@@ -42,7 +41,7 @@ import org.springframework.batch.retry.RetryPolicy;
  */
 public abstract class AbstractStatefulRetryPolicy implements RetryPolicy {
 
-	private volatile Set recoverableExceptionClasses = new HashSet();
+	private volatile Set<Class<?>> recoverableExceptionClasses = new HashSet<Class<?>>();
 
 	protected RetryContextCache retryContextCache = new MapRetryContextCache();
 
@@ -87,15 +86,15 @@ public abstract class AbstractStatefulRetryPolicy implements RetryPolicy {
 	 * 
 	 * @param retryableExceptionClasses defaults to {@link Exception}.
 	 */
-	public final void setRecoverableExceptionClasses(Class[] retryableExceptionClasses) {
-		Set temp = new HashSet();
+	public final void setRecoverableExceptionClasses(Class<?>[] retryableExceptionClasses) {
+		Set<Class<?>> temp = new HashSet<Class<?>>();
 		for (int i = 0; i < retryableExceptionClasses.length; i++) {
 			addRecoverableExceptionClass(retryableExceptionClasses[i], temp);
 		}
 		this.recoverableExceptionClasses = temp;
 	}
 
-	private void addRecoverableExceptionClass(Class retryableExceptionClass, Set set) {
+	private void addRecoverableExceptionClass(Class<?> retryableExceptionClass, Set<Class<?>> set) {
 		if (!Throwable.class.isAssignableFrom(retryableExceptionClass)) {
 			throw new IllegalArgumentException("Class '" + retryableExceptionClass.getName()
 					+ "' is not a subtype of Throwable.");
@@ -111,14 +110,13 @@ public abstract class AbstractStatefulRetryPolicy implements RetryPolicy {
 			return false;
 		}
 
-		Class exceptionClass = ex.getClass();
+		Class<? extends Throwable> exceptionClass = ex.getClass();
 		if (recoverableExceptionClasses.contains(exceptionClass)) {
 			return true;
 		}
 
 		// check for subclasses
-		for (Iterator iterator = recoverableExceptionClasses.iterator(); iterator.hasNext();) {
-			Class cls = (Class) iterator.next();
+		for (Class<?> cls : recoverableExceptionClasses) {
 			if (cls.isAssignableFrom(exceptionClass)) {
 				addRecoverableExceptionClass(exceptionClass, this.recoverableExceptionClasses);
 				return true;

spring-batch-infrastructure/src/main/java/org/springframework/batch/retry/policy/CompositeRetryPolicy.java

@@ -97,7 +97,7 @@ public class CompositeRetryPolicy extends AbstractStatelessRetryPolicy {
 	 * RetryContext)
 	 */
 	public RetryContext open(RetryCallback callback, RetryContext parent) {
-		List list = new ArrayList();
+		List<RetryContext> list = new ArrayList<RetryContext>();
 		for (int i = 0; i < policies.length; i++) {
 			list.add(policies[i].open(callback, parent));
 		}
@@ -124,9 +124,9 @@ public class CompositeRetryPolicy extends AbstractStatelessRetryPolicy {
 
 		RetryPolicy[] policies;
 
-		public CompositeRetryContext(RetryContext parent, List contexts) {
+		public CompositeRetryContext(RetryContext parent, List<RetryContext> contexts) {
 			super(parent);
-			this.contexts = (RetryContext[]) contexts.toArray(new RetryContext[0]);
+			this.contexts = contexts.toArray(new RetryContext[0]);
 			this.policies = CompositeRetryPolicy.this.policies;
 		}