001: /*
002: * $Id: ExpressionEvaluatorManager.java 11297 2008-03-09 20:11:02Z rossmason $
003: * --------------------------------------------------------------------------------------
004: * Copyright (c) MuleSource, Inc. All rights reserved. http://www.mulesource.com
005: *
006: * The software in this package is published under the terms of the CPAL v1.0
007: * license, a copy of which has been included with this distribution in the
008: * LICENSE.txt file.
009: */
010: package org.mule.util.expression;
011:
012: import org.mule.api.lifecycle.Disposable;
013: import org.mule.config.i18n.CoreMessages;
014:
015: import java.util.HashMap;
016: import java.util.Iterator;
017: import java.util.Map;
018:
019: /**
020: * Provides universal access for evaluating expressions embedded in Mule configurations, such as Xml, Java,
021: * scripting and annotations.
022: *
023: * Users can register or unregister {@link ExpressionEvaluator} through this interface.
024: * */
025: public class ExpressionEvaluatorManager {
026:
027: public static final String DEFAULT_EXPRESSION_PREFIX = "${";
028:
029: private static Map evaluator = new HashMap(8);
030:
031: public static void registerEvaluator(ExpressionEvaluator extractor) {
032: if (extractor == null) {
033: throw new IllegalArgumentException(CoreMessages
034: .objectIsNull("extractor").getMessage());
035: }
036: if (evaluator.containsKey(extractor.getName())) {
037: throw new IllegalArgumentException(CoreMessages
038: .objectAlreadyExists(extractor.getName())
039: .getMessage());
040: }
041: evaluator.put(extractor.getName(), extractor);
042: }
043:
044: public static boolean isEvaluatorRegistered(String name) {
045: return evaluator.get(name) != null;
046: }
047:
048: public static ExpressionEvaluator unregisterEvaluator(String name) {
049: if (name == null) {
050: return null;
051: }
052:
053: ExpressionEvaluator evaluator = (ExpressionEvaluator) ExpressionEvaluatorManager.evaluator
054: .remove(name);
055: if (evaluator instanceof Disposable) {
056: ((Disposable) evaluator).dispose();
057: }
058: return evaluator;
059: }
060:
061: public static Object evaluate(String expression, Object object)
062: throws ExpressionRuntimeException {
063: return evaluate(expression, object, DEFAULT_EXPRESSION_PREFIX,
064: false);
065: }
066:
067: public static Object evaluate(String expression, Object object,
068: boolean failIfNull) throws ExpressionRuntimeException {
069: return evaluate(expression, object, DEFAULT_EXPRESSION_PREFIX,
070: failIfNull);
071: }
072:
073: public static Object evaluate(String expression, Object object,
074: String expressionPrefix, boolean failIfNull)
075: throws ExpressionRuntimeException {
076: String name;
077:
078: if (expression == null) {
079: throw new IllegalArgumentException(CoreMessages
080: .objectIsNull("expression").getMessage());
081: }
082: if (expression.startsWith(expressionPrefix)) {
083: expression = expression.substring(2,
084: expression.length() - 1);
085: }
086: int i = expression.indexOf(":");
087: if (i > -1) {
088: name = expression.substring(0, i);
089: expression = expression.substring(i + 1);
090: } else {
091: name = expression;
092: expression = null;
093: }
094: ExpressionEvaluator extractor = (ExpressionEvaluator) evaluator
095: .get(name);
096: if (extractor == null) {
097: throw new IllegalArgumentException(CoreMessages
098: .expressionEvaluatorNotRegistered(name)
099: .getMessage());
100: }
101: Object result = extractor.evaluate(expression, object);
102: if (result == null && failIfNull) {
103: throw new ExpressionRuntimeException(CoreMessages
104: .expressionEvaluatorReturnedNull(name, expression));
105: }
106: return result;
107: }
108:
109: public static synchronized void clearEvaluators() {
110: for (Iterator iterator = evaluator.values().iterator(); iterator
111: .hasNext();) {
112: ExpressionEvaluator evaluator = (ExpressionEvaluator) iterator
113: .next();
114: if (evaluator instanceof Disposable) {
115: ((Disposable) evaluator).dispose();
116: }
117: }
118: evaluator.clear();
119: }
120:
121: public static boolean isValidExpression(String expression) {
122: return isValidExpression(expression, DEFAULT_EXPRESSION_PREFIX);
123: }
124:
125: public static boolean isValidExpression(String expression,
126: String expressionPrefix) {
127: if (expression.startsWith(expressionPrefix)) {
128: expression = expression.substring(2,
129: expression.length() - 1);
130: }
131: String name;
132: int i = expression.indexOf(":");
133: if (i > -1) {
134: name = expression.substring(0, i);
135: } else {
136: name = expression;
137: }
138: return isEvaluatorRegistered(name);
139: }
140:
141: }
|