Polish SpEL code

Author: philwebb

spring-expression/src/main/java/org/springframework/expression/ConstructorExecutor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 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.
@@ -19,13 +19,15 @@
 
 // TODO Is the resolver/executor model too pervasive in this package?
 /**
- * Executors are built by resolvers and can be cached by the infrastructure to repeat an operation quickly without going
- * back to the resolvers. For example, the particular constructor to run on a class may be discovered by the reflection
- * constructor resolver - it will then build a ConstructorExecutor that executes that constructor and the
- * ConstructorExecutor can be reused without needing to go back to the resolver to discover the constructor again.
+ * Executors are built by resolvers and can be cached by the infrastructure to repeat an
+ * operation quickly without going back to the resolvers. For example, the particular
+ * constructor to run on a class may be discovered by the reflection constructor resolver
+ * - it will then build a ConstructorExecutor that executes that constructor and the
+ * ConstructorExecutor can be reused without needing to go back to the resolver to
+ * discover the constructor again.
  *
- * They can become stale, and in that case should throw an AccessException - this will cause the infrastructure to go
- * back to the resolvers to ask for a new one.
+ * <p>They can become stale, and in that case should throw an AccessException - this will
+ * cause the infrastructure to go back to the resolvers to ask for a new one.
  *
  * @author Andy Clement
  * @since 3.0
@@ -34,11 +36,13 @@ public interface ConstructorExecutor {
 
 	/**
 	 * Execute a constructor in the specified context using the specified arguments.
+	 *
 	 * @param context the evaluation context in which the command is being executed
-	 * @param arguments the arguments to the constructor call, should match (in terms of number and type) whatever the
-	 * command will need to run
+	 * @param arguments the arguments to the constructor call, should match (in terms of
+	 *        number and type) whatever the command will need to run
 	 * @return the new object
-	 * @throws AccessException if there is a problem executing the command or the CommandExecutor is no longer valid
+	 * @throws AccessException if there is a problem executing the command or the
+	 *         CommandExecutor is no longer valid
 	 */
 	TypedValue execute(EvaluationContext context, Object... arguments) throws AccessException;
 

spring-expression/src/main/java/org/springframework/expression/ConstructorResolver.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 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.
@@ -21,18 +21,19 @@
 import org.springframework.core.convert.TypeDescriptor;
 
 /**
- * A constructor resolver attempts locate a constructor and returns a ConstructorExecutor that can be used to invoke
- * that constructor. The ConstructorExecutor will be cached but if it 'goes stale' the resolvers will be called again.
- *
+ * A constructor resolver attempts locate a constructor and returns a ConstructorExecutor
+ * that can be used to invoke that constructor. The ConstructorExecutor will be cached but
+ * if it 'goes stale' the resolvers will be called again.
+ * 
  * @author Andy Clement
  * @since 3.0
  */
 public interface ConstructorResolver {
 
 	/**
-	 * Within the supplied context determine a suitable constructor on the supplied type that can handle the
-	 * specified arguments. Return a ConstructorExecutor that can be used to invoke that constructor
-	 * (or {@code null} if no constructor could be found).
+	 * Within the supplied context determine a suitable constructor on the supplied type
+	 * that can handle the specified arguments. Return a ConstructorExecutor that can be
+	 * used to invoke that constructor (or {@code null} if no constructor could be found).
 	 * @param context the current evaluation context
 	 * @param typeName the type upon which to look for the constructor
 	 * @param argumentTypes the arguments that the constructor must be able to handle

spring-expression/src/main/java/org/springframework/expression/EvaluationContext.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2010 the original author or authors.
+ * Copyright 2002-2013 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.
@@ -19,12 +19,12 @@
 import java.util.List;
 
 /**
- * Expressions are executed in an evaluation context. It is in this context that references
- * are resolved when encountered during expression evaluation.
+ * Expressions are executed in an evaluation context. It is in this context that
+ * references are resolved when encountered during expression evaluation.
  *
  * <p>There is a default implementation of the EvaluationContext,
- * {@link org.springframework.expression.spel.support.StandardEvaluationContext}
- * that can be extended, rather than having to implement everything.
+ * {@link org.springframework.expression.spel.support.StandardEvaluationContext} that can
+ * be extended, rather than having to implement everything.
  *
  * @author Andy Clement
  * @author Juergen Hoeller
@@ -33,8 +33,9 @@
 public interface EvaluationContext {
 
 	/**
-	 * @return the default root context object against which unqualified properties/methods/etc
-	 * should be resolved. This can be overridden when evaluating an expression.
+	 * @return the default root context object against which unqualified
+	 *         properties/methods/etc should be resolved. This can be overridden when
+	 *         evaluating an expression.
 	 */
 	TypedValue getRootObject();
 
@@ -54,7 +55,8 @@ public interface EvaluationContext {
 	List<PropertyAccessor> getPropertyAccessors();
 
 	/**
-	 * @return a type locator that can be used to find types, either by short or fully qualified name.
+	 * @return a type locator that can be used to find types, either by short or fully
+	 *         qualified name.
 	 */
 	TypeLocator getTypeLocator();
 

spring-expression/src/main/java/org/springframework/expression/Expression.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 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.
@@ -19,10 +19,9 @@
 import org.springframework.core.convert.TypeDescriptor;
 
 /**
- * An expression capable of evaluating itself against context objects.
- * Encapsulates the details of a previously parsed expression string.
- * Provides a common abstraction for expression evaluation independent
- * of any language like OGNL or the Unified EL.
+ * An expression capable of evaluating itself against context objects. Encapsulates the
+ * details of a previously parsed expression string. Provides a common abstraction for
+ * expression evaluation independent of any language like OGNL or the Unified EL.
  *
  * @author Keith Donald
  * @author Andy Clement

spring-expression/src/main/java/org/springframework/expression/ExpressionException.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 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.
@@ -16,7 +16,6 @@
 
 package org.springframework.expression;
 
-
 /**
  * Super class for exceptions that can occur whilst processing expressions
  *
@@ -27,8 +26,10 @@
 public class ExpressionException extends RuntimeException {
 
 	protected String expressionString;
+
 	protected int position; // -1 if not known - but should be known in all reasonable cases
 
+
 	/**
 	 * Creates a new expression exception.
 	 * @param expressionString the expression string
@@ -85,15 +86,16 @@ public ExpressionException(String message, Throwable cause) {
 		super(message,cause);
 	}
 
+
 	public String toDetailedString() {
 		StringBuilder output = new StringBuilder();
-		if (expressionString!=null) {
+		if (this.expressionString!=null) {
 			output.append("Expression '");
-			output.append(expressionString);
+			output.append(this.expressionString);
 			output.append("'");
-			if (position!=-1) {
+			if (this.position!=-1) {
 				output.append(" @ ");
-				output.append(position);
+				output.append(this.position);
 			}
 			output.append(": ");
 		}
@@ -106,7 +108,7 @@ public final String getExpressionString() {
 	}
 
 	public final int getPosition() {
-		return position;
+		return this.position;
 	}
 
 }

spring-expression/src/main/java/org/springframework/expression/ExpressionInvocationTargetException.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 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.
@@ -13,13 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.springframework.expression;
 
 /**
- * This exception wraps (as cause) a checked exception thrown by some method that SpEL invokes.
- * It differs from a SpelEvaluationException because this indicates the occurrence of a checked exception
- * that the invoked method was defined to throw.  SpelEvaluationExceptions are for handling (and wrapping)
- * unexpected exceptions.
+ * This exception wraps (as cause) a checked exception thrown by some method that SpEL
+ * invokes. It differs from a SpelEvaluationException because this indicates the
+ * occurrence of a checked exception that the invoked method was defined to throw.
+ * SpelEvaluationExceptions are for handling (and wrapping) unexpected exceptions.
  *
  * @author Andy Clement
  * @since 3.0.3

spring-expression/src/main/java/org/springframework/expression/MethodExecutor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2009 the original author or authors.
+ * Copyright 2002-2013 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.
@@ -17,27 +17,31 @@
 package org.springframework.expression;
 
 /**
- * MethodExecutors are built by the resolvers and can be cached by the infrastructure to repeat an operation quickly
- * without going back to the resolvers. For example, the particular method to run on an object may be discovered by the
- * reflection method resolver - it will then build a MethodExecutor that executes that method and the MethodExecutor can
- * be reused without needing to go back to the resolver to discover the method again.
+ * MethodExecutors are built by the resolvers and can be cached by the infrastructure to
+ * repeat an operation quickly without going back to the resolvers. For example, the
+ * particular method to run on an object may be discovered by the reflection method
+ * resolver - it will then build a MethodExecutor that executes that method and the
+ * MethodExecutor can be reused without needing to go back to the resolver to discover the
+ * method again.
  *
- * <p>They can become stale, and in that case should throw an AccessException - this will cause the infrastructure to go
- * back to the resolvers to ask for a new one.
+ * <p>They can become stale, and in that case should throw an AccessException - this will
+ * cause the infrastructure to go back to the resolvers to ask for a new one.
  *
  * @author Andy Clement
  * @since 3.0
  */
 public interface MethodExecutor {
 
 	/**
-	 * Execute a command using the specified arguments, and using the specified expression state.
+	 * Execute a command using the specified arguments, and using the specified expression
+	 * state.
 	 * @param context the evaluation context in which the command is being executed
 	 * @param target the target object of the call - null for static methods
-	 * @param arguments the arguments to the executor, should match (in terms of number and type) whatever the
-	 * command will need to run
+	 * @param arguments the arguments to the executor, should match (in terms of number
+	 *        and type) whatever the command will need to run
 	 * @return the value returned from execution
-	 * @throws AccessException if there is a problem executing the command or the MethodExecutor is no longer valid
+	 * @throws AccessException if there is a problem executing the command or the
+	 *         MethodExecutor is no longer valid
 	 */
 	TypedValue execute(EvaluationContext context, Object target, Object... arguments) throws AccessException;
 

spring-expression/src/main/java/org/springframework/expression/MethodFilter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 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.
@@ -13,31 +13,31 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.springframework.expression;
 
 import java.lang.reflect.Method;
 import java.util.List;
 
 /**
- * MethodFilter instances allow SpEL users to fine tune the behaviour of the method resolution
- * process.  Method resolution (which translates from a method name in an expression to a real
- * method to invoke) will normally retrieve candidate methods for invocation via a simple call
- * to 'Class.getMethods()' and will choose the first one that is suitable for the
- * input parameters.  By registering a MethodFilter the user can receive a callback
- * and change the methods that will be considered suitable.
+ * MethodFilter instances allow SpEL users to fine tune the behaviour of the method
+ * resolution process. Method resolution (which translates from a method name in an
+ * expression to a real method to invoke) will normally retrieve candidate methods for
+ * invocation via a simple call to 'Class.getMethods()' and will choose the first one that
+ * is suitable for the input parameters. By registering a MethodFilter the user can
+ * receive a callback and change the methods that will be considered suitable.
  *
  * @author Andy Clement
  * @since 3.0.1
  */
 public interface MethodFilter {
 
 	/**
-	 * Called by the method resolver to allow the SpEL user to organize the list of candidate
-	 * methods that may be invoked.  The filter can remove methods that should not be
-	 * considered candidates and it may sort the results.  The resolver will then search
-	 * through the methods as returned from the filter when looking for a suitable
+	 * Called by the method resolver to allow the SpEL user to organize the list of
+	 * candidate methods that may be invoked. The filter can remove methods that should
+	 * not be considered candidates and it may sort the results. The resolver will then
+	 * search through the methods as returned from the filter when looking for a suitable
 	 * candidate to invoke.
-	 *
 	 * @param methods the full list of methods the resolver was going to choose from
 	 * @return a possible subset of input methods that may be sorted by order of relevance
 	 */

spring-expression/src/main/java/org/springframework/expression/MethodResolver.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 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.
@@ -21,22 +21,24 @@
 import org.springframework.core.convert.TypeDescriptor;
 
 /**
- * A method resolver attempts locate a method and returns a command executor that can be used to invoke that method.
- * The command executor will be cached but if it 'goes stale' the resolvers will be called again.
+ * A method resolver attempts locate a method and returns a command executor that can be
+ * used to invoke that method. The command executor will be cached but if it 'goes stale'
+ * the resolvers will be called again.
  *
  * @author Andy Clement
  * @since 3.0
  */
 public interface MethodResolver {
 
 	/**
-	 * Within the supplied context determine a suitable method on the supplied object that can handle the
-	 * specified arguments. Return a MethodExecutor that can be used to invoke that method
-	 * (or {@code null} if no method could be found).
+	 * Within the supplied context determine a suitable method on the supplied object that
+	 * can handle the specified arguments. Return a MethodExecutor that can be used to
+	 * invoke that method (or {@code null} if no method could be found).
 	 * @param context the current evaluation context
 	 * @param targetObject the object upon which the method is being called
 	 * @param argumentTypes the arguments that the constructor must be able to handle
-	 * @return a MethodExecutor that can invoke the method, or null if the method cannot be found
+	 * @return a MethodExecutor that can invoke the method, or null if the method cannot
+	 *         be found
 	 */
 	MethodExecutor resolve(EvaluationContext context, Object targetObject, String name,
 			List<TypeDescriptor> argumentTypes) throws AccessException;

spring-expression/src/main/java/org/springframework/expression/Operation.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 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.
@@ -17,13 +17,24 @@
 package org.springframework.expression;
 
 /**
- * Supported operations that an {@link OperatorOverloader} can implement for any pair of operands.
+ * Supported operations that an {@link OperatorOverloader} can implement for any pair of
+ * operands.
  *
  * @author Andy Clement
  * @since 3.0
  */
 public enum Operation {
 
-	ADD, SUBTRACT, DIVIDE, MULTIPLY, MODULUS, POWER
+	ADD,
+
+	SUBTRACT,
+
+	DIVIDE,
+
+	MULTIPLY,
+
+	MODULUS,
+
+	POWER
 
 }