Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2004-2008 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.
   * 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.springframework.binding.expression.el;
 
 import java.util.Map;
 
 
The expression parser that parses EL expressions.

Author(s):
Keith Donald
Jeremy Grelle
 
 public class ELExpressionParser implements ExpressionParser {
 
 
 	private Map contextFactories = new HashMap();
 
Creates a new EL expression parser for standalone usage.
 
 	public ELExpressionParser(ExpressionFactory expressionFactory) {
 		init(expressionFactory);
 	}

The conversion service to use to perform type conversions as needed by the Unified EL system. If not specified, the default is an instance of org.springframework.binding.convert.service.DefaultConversionService.
 
 	}

Sets the conversion service to use to perform type conversions as needed by the Unified EL system.

Parameters:
conversionService the conversion service to use
 
 	public void setConversionService(ConversionService conversionService) {
 		Assert.notNull(conversionService"The conversion service is required");
 		this. = conversionService;
 	}

Register the ELContextFactory for expressions that evaluate the given class of context object.

Parameters:
contextType the expression context class
contextFactory the context factory to use for expressions that evaluate those types of contexts
 
 	public void putContextFactory(Class contextTypeELContextFactory contextFactory) {
 		Assert.notNull(contextFactory"The EL context factory cannot be null");
 		.put(contextTypecontextFactory);
 	}
 
 	public Expression parseExpression(String expressionStringParserContext contextthrows ParserException {
 		Assert.notNull(expressionString"The expression string to parse is required");
 		if (context == null) {
 		}
 		if (context.isTemplate()) {
 			return parseExpressionInternal(expressionStringcontexttrue);
 		} else {
 			assertNotDelimited(expressionString);
 			assertHasText(expressionString);
 			return parseExpressionInternal("#{" + expressionString + "}"contextfalse);
 		}
 	}
	private Expression parseExpressionInternal(String expressionStringParserContext contextboolean template)
			throws ParserException {
		Assert.notNull(expressionString"The expression string to parse is required");
		try {
			ValueExpression expression = parseValueExpression(expressionStringcontext);
			ELContextFactory contextFactory = getContextFactory(context.getEvaluationContextType(), expressionString);
			return new ELExpression(contextFactoryexpression);
catch (ELException e) {
			throw new ParserException(expressionStringe);
		}
	}
	private ValueExpression parseValueExpression(String expressionStringParserContext contextthrows ELException {
		ParserELContext elContext = new ParserELContext();
		ValueExpression expression = .createValueExpression(elContextexpressionStringObject.class);
		return new BindingValueExpression(expressiongetExpectedType(context), context.isTemplate());
	}
	private Class getExpectedType(ParserContext context) {
		Class expectedType = context.getExpectedEvaluationResultType();
		return expectedType != null ? expectedType : Object.class;
	}
	private ELContextFactory getContextFactory(Class expressionTargetTypeString expressionString) {
		if (.containsKey(expressionTargetType)) {
			return (ELContextFactory.get(expressionTargetType);
else {
		}
	}
	private void init(ExpressionFactory expressionFactory) {
		this. = expressionFactory;
		putContextFactory(nullcontextFactory);
		putContextFactory(Object.classcontextFactory);
	}
	private void assertNotDelimited(String expressionString) {
		if ((expressionString.startsWith("#{") && expressionString.endsWith("}"))
				|| (expressionString.startsWith("${") && expressionString.endsWith("}"))) {
			throw new ParserException(expressionString"This expression '" + expressionString
"' being parsed is expected be an 'eval' EL expression string. "
"Do not attempt to enclose such expression strings in #{} or ${} delimiters. "
"If you need to parse a template that mixes literal text with evaluatable blocks, "
"set the 'template' parser context attribute to true."null);
		}
	}
	private void assertHasText(String expressionString) {
		if (expressionString.length() == 0) {
			throw new ParserException(expressionString"The EL eval expression to parse must have text"null);
		}
	}
	private class ParserELContext extends ELContext {
			return null;
		}
			return null;
		}
		}
		public void mapVariables(ExpressionVariable[] variablesExpressionFactory expressionFactory) {
			if (variables != null && variables.length > 0) {
				for (int i = 0; i < variables.lengthi++) {
					ExpressionVariable var = variables[i];
					ParserContext context = var.getParserContext() != null ? var.getParserContext()
					if (context.isTemplate()) {
						expr = parseValueExpression(var.getValueExpression(), context);
else {
						expr = parseValueExpression("#{" + var.getValueExpression() + "}"context);
					}
				}
			}
		}
	}
	private static class VariableMapperImpl extends VariableMapper {
		private Map variables = new HashMap();
			return (ValueExpression.get(name);
		}
			return (ValueExpression.put(namevalue);
		}
		public String toString() {
		}
	}
New to GrepCode? Check out our FAQ X