Convert cache package line endings from CRLF => LF

Unfortunately creates a large diff due to whitespace changes as well as
false attribution of authorship from a git/svn 'blame' perspective.

Be sure to perform diffs using `git diff -w` or `svn diff -w` when
reviewing recent changes to these sources to ignore all whitespace.

org.springframework.context/src/main/java/org/springframework/cache/Cache.java

@@ -21,7 +21,7 @@ package org.springframework.cache;
  *
  * <b>Note:</b> Due to the generic use of caching, it is recommended that
  * implementations allow storage of <tt>null</tt> values (for example to
- * cache methods that return <code>null</code>).
+ * cache methods that return {@code null}).
  *
  * @author Costin Leau
  * @since 3.1

org.springframework.context/src/main/java/org/springframework/cache/CacheManager.java

@@ -28,8 +28,8 @@ public interface CacheManager {
 
 	/**
 	 * Return the cache associated with the given name.
-	 * @param name cache identifier (must not be <code>null</code>)
+	 * @param name cache identifier (must not be {@code null})
-	 * @return associated cache, or <code>null</code> if none is found
+	 * @return associated cache, or {@code null} if none is found
 	 */
 	Cache getCache(String name);
 

org.springframework.context/src/main/java/org/springframework/cache/annotation/CacheAnnotationParser.java

@@ -21,7 +21,6 @@ import java.util.Collection;
 
 import org.springframework.cache.interceptor.CacheOperation;
 
-
 /**
  * Strategy interface for parsing known caching annotation types.
  * {@link AnnotationCacheDefinitionSource} delegates to such
@@ -37,11 +36,11 @@ public interface CacheAnnotationParser {
 	 * Parses the cache definition for the given method or class,
 	 * based on a known annotation type.
 	 * <p>This essentially parses a known cache annotation into Spring's
-	 * metadata attribute class. Returns <code>null</code> if the method/class
+	 * metadata attribute class. Returns {@code null} if the method/class
 	 * is not cacheable.
 	 * @param ae the annotated method or class
 	 * @return CacheOperation the configured caching operation,
-	 * or <code>null</code> if none was found
+	 * or {@code null} if none was found
 	 * @see AnnotationCacheOperationSource#determineCacheOperation
 	 */
 	Collection<CacheOperation> parseCacheAnnotations(AnnotatedElement ae);

org.springframework.context/src/main/java/org/springframework/cache/annotation/CacheDefinitions.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011 the original author or authors.
+ * Copyright 2002-2011 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,6 +27,7 @@ import java.lang.annotation.Target;
  * Group annotation for multiple cache annotations (of different or the same type).
  *
  * @author Costin Leau
+ * @author Chris Beams
  * @since 3.1
  */
 @Target({ ElementType.METHOD, ElementType.TYPE })

org.springframework.context/src/main/java/org/springframework/cache/annotation/CachePut.java

@@ -26,7 +26,6 @@ import java.lang.annotation.Target;
 import org.springframework.cache.Cache;
 
 /**
- * 
  * Annotation indicating that a method (or all methods on a class) trigger(s)
  * a {@link Cache#put(Object, Object)} operation. As opposed to {@link Cacheable} annotation,
  * this annotation does not cause the target method to be skipped - rather it

org.springframework.context/src/main/java/org/springframework/cache/annotation/SpringCacheAnnotationParser.java

@@ -29,7 +29,8 @@ import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.util.ObjectUtils;
 
 /**
- * Strategy implementation for parsing Spring's {@link Cacheable}, {@link CacheEvict} and {@link CachePut} annotations.
+ * Strategy implementation for parsing Spring's {@link Cacheable},
+ * {@link CacheEvict} and {@link CachePut} annotations.
  *
  * @author Costin Leau
  * @author Juergen Hoeller

org.springframework.context/src/main/java/org/springframework/cache/annotation/package-info.java

@@ -1,9 +1,8 @@
 
 /**
- * JDK 1.5+ annotation for caching demarcation.
+ * Annotations and supporting classes for declarative cache management.
  * Hooked into Spring's caching interception infrastructure
- * via CacheOperationSource implementation.
+ * via {@link org.springframework.cache.interceptor.CacheOperationSource
- *
+ * CacheOperationSource} implementation.
  */
 package org.springframework.cache.annotation;
-

org.springframework.context/src/main/java/org/springframework/cache/concurrent/ConcurrentMapCache.java

@@ -25,14 +25,14 @@ import org.springframework.cache.support.ValueWrapperImpl;
 
 /**
  * Simple {@link Cache} implementation based on the core JDK
- * <code>java.util.concurrent</code> package.
+ * {@code java.util.concurrent} package.
  *
  * <p>Useful for testing or simple caching scenarios, typically in combination
  * with {@link org.springframework.cache.support.SimpleCacheManager} or
  * dynamically through {@link ConcurrentMapCacheManager}.
  *
  * <p><b>Note:</b> As {@link ConcurrentHashMap} (the default implementation used)
- * does not allow for <code>null</code> values to be stored, this class will replace
+ * does not allow for {@code null} values to be stored, this class will replace
  * them with a predefined internal object. This behavior can be changed through the
  * {@link #ConcurrentMapCache(String, ConcurrentMap, boolean)} constructor.
  *

org.springframework.context/src/main/java/org/springframework/cache/concurrent/ConcurrentMapCacheFactoryBean.java

@@ -66,7 +66,7 @@ public class ConcurrentMapCacheFactoryBean
 	}
 
 	/**
-	 * Set whether to allow <code>null</code> values
+	 * Set whether to allow {@code null} values
 	 * (adapting them to an internal null holder value).
 	 * <p>Default is "true".
 	 */

org.springframework.context/src/main/java/org/springframework/cache/concurrent/package-info.java

@@ -1,10 +1,9 @@
 
 /**
- *
+ * Implementation package for {@code java.util.concurrent} based caches.
- * Implementation package for java.util.concurrent based
+ * Provides a {@link org.springframework.cache.CacheManager CacheManager}
- * caches. Provides a CacheManager and Cache implementation
+ * and {@link org.springframework.cache.Cache Cache} implementation for
- * for usage in a Spring context.
+ * use in a Spring context.
- * 
  */
 package org.springframework.cache.concurrent;
 

org.springframework.context/src/main/java/org/springframework/cache/config/AnnotationDrivenCacheBeanDefinitionParser.java

@@ -33,14 +33,15 @@ import org.w3c.dom.Element;
 
 /**
  * {@link org.springframework.beans.factory.xml.BeanDefinitionParser}
- * implementation that allows users to easily configure all the infrastructure
+ * implementation that allows users to easily configure all the
- * beans required to enable annotation-driven cache demarcation.
+ * infrastructure beans required to enable annotation-driven cache
+ * demarcation.
  *
- * <p>By default, all proxies are created as JDK proxies. This may cause some
+ * <p>By default, all proxies are created as JDK proxies. This may cause
- * problems if you are injecting objects as concrete classes rather than
+ * some problems if you are injecting objects as concrete classes rather
- * interfaces. To overcome this restriction you can set the
+ * than interfaces. To overcome this restriction you can set the
- * '<code>proxy-target-class</code>' attribute to '<code>true</code>', which
+ * '{@code proxy-target-class}' attribute to '{@code true}', which will
- * will result in class-based proxies being created.
+ * result in class-based proxies being created.
  *
  * @author Costin Leau
  * @since 3.1
@@ -48,9 +49,9 @@ import org.w3c.dom.Element;
 class AnnotationDrivenCacheBeanDefinitionParser implements BeanDefinitionParser {
 
 	/**
-	 * Parses the '<code>&lt;cache:annotation-driven/&gt;</code>' tag. Will
+	 * Parses the '{@code <cache:annotation-driven>}' tag. Will
-	 * {@link AopNamespaceUtils#registerAutoProxyCreatorIfNecessary register an AutoProxyCreator}
+	 * {@link AopNamespaceUtils#registerAutoProxyCreatorIfNecessary
-	 * with the container as necessary.
+	 * register an AutoProxyCreator} with the container as necessary.
 	 */
 	public BeanDefinition parse(Element element, ParserContext parserContext) {
 		String mode = element.getAttribute("mode");

org.springframework.context/src/main/java/org/springframework/cache/config/CacheAdviceParser.java

@@ -44,7 +44,6 @@ import org.w3c.dom.Element;
  * BeanDefinitionParser} for the {@code <tx:advice/>} tag.
  *
  * @author Costin Leau
- *
  */
 class CacheAdviceParser extends AbstractSingleBeanDefinitionParser {
 

org.springframework.context/src/main/java/org/springframework/cache/config/CacheNamespaceHandler.java

@@ -23,8 +23,8 @@ import org.springframework.util.StringUtils;
 import org.w3c.dom.Element;
 
 /**
- * <code>NamespaceHandler</code> allowing for the configuration of
+ * {@code NamespaceHandler} allowing for the configuration of declarative
- * declarative cache management using either XML or using annotations.
+ * cache management using either XML or using annotations.
  *
  * <p>This namespace handler is the central piece of functionality in the
  * Spring cache management facilities.

org.springframework.context/src/main/java/org/springframework/cache/config/package-info.java

@@ -1,9 +1,8 @@
 
 /**
- *
+ * Support package for declarative caching configuration, with XML
- * Support package for declarative caching configuration,
+ * schema being the primary configuration format. See {@link
- * with XML schema being the primary configuration format.
+ * org.springframework.cache.annotation.EnableCaching EnableCaching}
- *
+ * for details on code-based configuration without XML.
  */
 package org.springframework.cache.config;
-

org.springframework.context/src/main/java/org/springframework/cache/interceptor/AbstractFallbackCacheOperationSource.java

@@ -31,18 +31,21 @@ import org.springframework.util.ObjectUtils;
 
 /**
  * Abstract implementation of {@link CacheOperation} that caches
- * attributes for methods and implements a fallback policy: 1. specific target
+ * attributes for methods and implements a fallback policy: 1. specific
- * method; 2. target class; 3. declaring method; 4. declaring class/interface.
+ * target method; 2. target class; 3. declaring method; 4. declaring
+ * class/interface.
  *
  * <p>Defaults to using the target class's caching attribute if none is
- * associated with the target method. Any caching attribute associated with
+ * associated with the target method. Any caching attribute associated
- * the target method completely overrides a class caching attribute.
+ * with the target method completely overrides a class caching attribute.
- * If none found on the target class, the interface that the invoked method
+ * If none found on the target class, the interface that the invoked
- * has been called through (in case of a JDK proxy) will be checked.
+ * method has been called through (in case of a JDK proxy) will be
+ * checked.
  *
- * <p>This implementation caches attributes by method after they are first used.
+ * <p>This implementation caches attributes by method after they are
- * If it is ever desirable to allow dynamic changing of cacheable attributes
+ * first used. If it is ever desirable to allow dynamic changing of
- * (which is very unlikely), caching could be made configurable.
+ * cacheable attributes (which is very unlikely), caching could be made
+ * configurable.
  *
  * @author Costin Leau
  * @since 3.1
@@ -73,9 +76,9 @@ public abstract class AbstractFallbackCacheOperationSource implements CacheOpera
 	/**
 	 * Determine the caching attribute for this method invocation.
 	 * <p>Defaults to the class's caching attribute if no method attribute is found.
-	 * @param method the method for the current invocation (never <code>null</code>)
+	 * @param method the method for the current invocation (never {@code null})
-	 * @param targetClass the target class for this invocation (may be <code>null</code>)
+	 * @param targetClass the target class for this invocation (may be {@code null})
-	 * @return {@link CacheOperation} for this method, or <code>null</code> if the method
+	 * @return {@link CacheOperation} for this method, or {@code null} if the method
 	 * is not cacheable
 	 */
 	public Collection<CacheOperation> getCacheOperations(Method method, Class<?> targetClass) {
@@ -111,9 +114,9 @@ public abstract class AbstractFallbackCacheOperationSource implements CacheOpera
 	 * Determine a cache key for the given method and target class.
 	 * <p>Must not produce same key for overloaded methods.
 	 * Must produce same key for different instances of the same method.
-	 * @param method the method (never <code>null</code>)
+	 * @param method the method (never {@code null})
-	 * @param targetClass the target class (may be <code>null</code>)
+	 * @param targetClass the target class (may be {@code null})
-	 * @return the cache key (never <code>null</code>)
+	 * @return the cache key (never {@code null})
 	 */
 	protected Object getCacheKey(Method method, Class<?> targetClass) {
 		return new DefaultCacheKey(method, targetClass);
@@ -161,7 +164,7 @@ public abstract class AbstractFallbackCacheOperationSource implements CacheOpera
 	 * for the given method, if any.
 	 * @param method the method to retrieve the attribute for
 	 * @return all caching attribute associated with this method
-	 * (or <code>null</code> if none)
+	 * (or {@code null} if none)
 	 */
 	protected abstract Collection<CacheOperation> findCacheOperations(Method method);
 
@@ -170,13 +173,13 @@ public abstract class AbstractFallbackCacheOperationSource implements CacheOpera
 	 * for the given class, if any.
 	 * @param clazz the class to retrieve the attribute for
 	 * @return all caching attribute associated with this class
-	 * (or <code>null</code> if none)
+	 * (or {@code null} if none)
 	 */
 	protected abstract Collection<CacheOperation> findCacheOperations(Class<?> clazz);
 
 	/**
 	 * Should only public methods be allowed to have caching semantics?
-	 * <p>The default implementation returns <code>false</code>.
+	 * <p>The default implementation returns {@code false}.
 	 */
 	protected boolean allowPublicMethodsOnly() {
 		return false;

org.springframework.context/src/main/java/org/springframework/cache/interceptor/CacheAspectSupport.java

@@ -39,14 +39,16 @@ import org.springframework.util.StringUtils;
  * Base class for caching aspects, such as the {@link CacheInterceptor}
  * or an AspectJ aspect.
  *
- * <p>This enables the underlying Spring caching infrastructure to be used easily
+ * <p>This enables the underlying Spring caching infrastructure to be
- * to implement an aspect for any aspect system.
+ * used easily to implement an aspect for any aspect system.
  *
- * <p>Subclasses are responsible for calling methods in this class in the correct order.
+ * <p>Subclasses are responsible for calling methods in this class in
+ * the correct order.
  *
- * <p>Uses the <b>Strategy</b> design pattern. A {@link CacheManager} implementation will
+ * <p>Uses the <b>Strategy</b> design pattern. A {@link CacheManager}
- * perform the actual cache management, and a {@link CacheOperationSource} is used for
+ * implementation will perform the actual cache management, and a
- * determining caching operation definitions.
+ * {@link CacheOperationSource} is used for determining caching
+ * operation definitions.
  *
  * <p>A cache aspect is serializable if its {@code CacheManager} and
  * {@code CacheOperationSource} are serializable.

org.springframework.context/src/main/java/org/springframework/cache/interceptor/CacheOperation.java

@@ -80,7 +80,7 @@ public abstract class CacheOperation {
 	}
 
 	/**
-	 * This implementation compares the <code>toString()</code> results.
+	 * This implementation compares the {@code toString()} results.
 	 * @see #toString()
 	 */
 	@Override
@@ -89,7 +89,7 @@ public abstract class CacheOperation {
 	}
 
 	/**
-	 * This implementation returns <code>toString()</code>'s hash code.
+	 * This implementation returns {@code toString()}'s hash code.
 	 * @see #toString()
 	 */
 	@Override
@@ -99,8 +99,8 @@ public abstract class CacheOperation {
 
 	/**
 	 * Return an identifying description for this cache operation.
-	 * <p>Has to be overridden in subclasses for correct <code>equals</code>
+	 * <p>Has to be overridden in subclasses for correct {@code equals}
-	 * and <code>hashCode</code> behavior. Alternatively, {@link #equals}
+	 * and {@code hashCode} behavior. Alternatively, {@link #equals}
 	 * and {@link #hashCode} can be overridden themselves.
 	 */
 	@Override
@@ -110,7 +110,7 @@ public abstract class CacheOperation {
 
 	/**
 	 * Return an identifying description for this caching operation.
-	 * <p>Available to subclasses, for inclusion in their <code>toString()</code> result.
+	 * <p>Available to subclasses, for inclusion in their {@code toString()} result.
 	 */
 	protected StringBuilder getOperationDescription() {
 		StringBuilder result = new StringBuilder();

org.springframework.context/src/main/java/org/springframework/cache/interceptor/CacheOperationSource.java

@@ -31,12 +31,12 @@ public interface CacheOperationSource {
 
 	/**
 	 * Return the cache operation definition for this method,
-	 * or <code>null</code> if the method contains no "cacheable" annotations.
+	 * or {@code null} if the method contains no "cacheable" annotations.
 	 * @param method the method to introspect
-	 * @param targetClass the target class (may be <code>null</code>,
+	 * @param targetClass the target class (may be {@code null},
 	 * in which case the declaring class of the method must be used)
 	 * @return {@link CacheOperation} the matching cache operation,
-	 * or <code>null</code> if none found
+	 * or {@code null} if none found
 	 */
 	Collection<CacheOperation> getCacheOperations(Method method, Class<?> targetClass);
 

org.springframework.context/src/main/java/org/springframework/cache/interceptor/CacheOperationSourcePointcut.java

@@ -63,7 +63,7 @@ abstract class CacheOperationSourcePointcut extends StaticMethodMatcherPointcut
 
 
 	/**
-	 * Obtain the underlying CacheOperationDefinitionSource (may be <code>null</code>).
+	 * Obtain the underlying CacheOperationDefinitionSource (may be {@code null}).
 	 * To be implemented by subclasses.
 	 */
 	protected abstract CacheOperationSource getCacheOperationSource();

org.springframework.context/src/main/java/org/springframework/cache/interceptor/CachePutOperation.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011 the original author or authors.
+ * Copyright 2002-2011 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

org.springframework.context/src/main/java/org/springframework/cache/interceptor/DefaultKeyGenerator.java

@@ -21,9 +21,10 @@ import java.lang.reflect.Method;
 import org.springframework.cache.interceptor.KeyGenerator;
 
 /**
- * Default key generator. Returns {@value #NO_PARAM_KEY} if no parameters are provided,
+ * Default key generator. Returns {@value #NO_PARAM_KEY} if no
- * the parameter itself if only one is given or a hash code computed from all given
+ * parameters are provided, the parameter itself if only one is given or
- * parameters' hash code values. Uses the constant value {@value #NULL_PARAM_KEY} for any
+ * a hash code computed from all given parameters' hash code values.
+ * Uses the constant value {@value #NULL_PARAM_KEY} for any
  * {@code null} parameters given.
  *
  * @author Costin Leau

org.springframework.context/src/main/java/org/springframework/cache/interceptor/LazyParamAwareEvaluationContext.java

@@ -25,12 +25,12 @@ import org.springframework.expression.spel.support.StandardEvaluationContext;
 import org.springframework.util.ObjectUtils;
 
 /**
- * Evaluation context class that adds a method parameters as SpEL variables,
+ * Evaluation context class that adds a method parameters as SpEL
- * in a lazy manner. The lazy nature eliminates unneeded parsing of classes
+ * variables, in a lazy manner. The lazy nature eliminates unneeded
- * byte code for parameter discovery.
+ * parsing of classes byte code for parameter discovery.
  *
- * <p>To limit the creation of objects, an ugly constructor is used (rather then
+ * <p>To limit the creation of objects, an ugly constructor is used
- * a dedicated 'closure'-like class for deferred execution).
+ * (rather then a dedicated 'closure'-like class for deferred execution).
  *
  * @author Costin Leau
  * @since 3.1

org.springframework.context/src/main/java/org/springframework/cache/interceptor/package-info.java

@@ -1,8 +1,6 @@
 /**
  * AOP-based solution for declarative caching demarcation.
  * Builds on the AOP infrastructure in org.springframework.aop.framework.
- * Any POJO can be cache advised with Spring.
+ * Any POJO can be cache-advised with Spring.
- * 
  */
 package org.springframework.cache.interceptor;
-

org.springframework.context/src/main/java/org/springframework/cache/package-info.java

@@ -1,7 +1,5 @@
 /**
  * Spring's generic cache abstraction.
  * Concrete implementations are provided in the subpackages.
- *
  */
 package org.springframework.cache;
-

org.springframework.context/src/main/java/org/springframework/cache/support/AbstractCacheManager.java

@@ -29,8 +29,9 @@ import org.springframework.cache.CacheManager;
 import org.springframework.util.Assert;
 
 /**
- * Abstract base class implementing the common CacheManager methods.
+ * Abstract base class implementing the common {@link CacheManager}
- * Useful for 'static' environments where the backing caches do not change.
+ * methods. Useful for 'static' environments where the backing caches do
+ * not change.
  *
  * @author Costin Leau
  * @author Juergen Hoeller

org.springframework.context/src/main/java/org/springframework/cache/support/CompositeCacheManager.java

@@ -52,8 +52,8 @@ public class CompositeCacheManager implements InitializingBean, CacheManager {
 
 	/**
 	 * Indicate whether a {@link NoOpCacheManager} should be added at the end of the manager lists.
-	 * In this case, any <code>getCache</code> requests not handled by the configured cache managers will
+	 * In this case, any {@code getCache} requests not handled by the configured cache managers will
-	 * be automatically handled by the {@link NoOpCacheManager} (and hence never return <code>null</code>).
+	 * be automatically handled by the {@link NoOpCacheManager} (and hence never return {@code null}).
 	 */
 	public void setFallbackToNoOpCache(boolean fallbackToNoOpCache) {
 		this.fallbackToNoOpCache = fallbackToNoOpCache;

org.springframework.context/src/main/java/org/springframework/cache/support/NoOpCacheManager.java

@@ -27,8 +27,9 @@ import org.springframework.cache.Cache;
 import org.springframework.cache.CacheManager;
 
 /**
- * A basic, no operation {@link CacheManager} implementation suitable for disabling caching, 
+ * A basic, no operation {@link CacheManager} implementation suitable
- * typically used for backing cache declarations without an actual backing store.
+ * for disabling caching, typically used for backing cache declarations
+ * without an actual backing store.
  *
  * <p>Will simply accept any items into the cache not actually storing them.
  *

org.springframework.context/src/main/java/org/springframework/cache/support/package-info.java

@@ -3,4 +3,3 @@
  * Provides abstract classes for cache managers and caches.
  */
 package org.springframework.cache.support;
-