| /** |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You 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.apache.camel.builder; |
| |
| import java.util.Map; |
| |
| import org.apache.camel.Expression; |
| import org.apache.camel.builder.xml.Namespaces; |
| import org.apache.camel.model.ExpressionNode; |
| import org.apache.camel.model.language.ExpressionDefinition; |
| |
| /** |
| * Represents an expression clause within the DSL which when the expression is |
| * complete the clause continues to another part of the DSL |
| * |
| * @version |
| */ |
| public class ExpressionClause<T> extends ExpressionDefinition { |
| private ExpressionClauseSupport<T> delegate; |
| |
| public ExpressionClause(T result) { |
| this.delegate = new ExpressionClauseSupport<T>(result); |
| } |
| |
| public static <T extends ExpressionNode> ExpressionClause<T> createAndSetExpression(T result) { |
| ExpressionClause<T> clause = new ExpressionClause<T>(result); |
| result.setExpression(clause); |
| return clause; |
| } |
| |
| // Helper expressions |
| // ------------------------------------------------------------------------- |
| |
| /** |
| * Specify an {@link Expression} instance |
| */ |
| public T expression(Expression expression) { |
| return delegate.expression(expression); |
| } |
| |
| /** |
| * Specify the constant expression value |
| */ |
| public T constant(Object value) { |
| return delegate.constant(value); |
| } |
| |
| /** |
| * An expression of the exchange |
| */ |
| public T exchange() { |
| return delegate.exchange(); |
| } |
| |
| /** |
| * An expression of an inbound message |
| */ |
| public T inMessage() { |
| return delegate.inMessage(); |
| } |
| |
| /** |
| * An expression of an inbound message |
| */ |
| public T outMessage() { |
| return delegate.outMessage(); |
| } |
| |
| /** |
| * An expression of an inbound message body |
| */ |
| public T body() { |
| return delegate.body(); |
| } |
| |
| /** |
| * An expression of an inbound message body converted to the expected type |
| */ |
| public T body(Class<?> expectedType) { |
| return delegate.body(expectedType); |
| } |
| |
| /** |
| * An expression of an outbound message body |
| */ |
| public T outBody() { |
| return delegate.outBody(); |
| } |
| |
| /** |
| * An expression of an outbound message body converted to the expected type |
| */ |
| public T outBody(Class expectedType) { |
| return delegate.outBody(expectedType); |
| } |
| |
| /** |
| * An expression of an inbound message header of the given name |
| */ |
| public T header(String name) { |
| return delegate.header(name); |
| } |
| |
| /** |
| * An expression of the inbound headers |
| */ |
| public T headers() { |
| return delegate.headers(); |
| } |
| |
| /** |
| * An expression of an outbound message header of the given name |
| */ |
| public T outHeader(String name) { |
| return delegate.outHeader(name); |
| } |
| |
| /** |
| * An expression of the outbound headers |
| */ |
| public T outHeaders() { |
| return delegate.outHeaders(); |
| } |
| |
| /** |
| * An expression of an exchange property of the given name |
| */ |
| public T property(String name) { |
| return delegate.property(name); |
| } |
| |
| /** |
| * An expression of the exchange properties |
| */ |
| public T properties() { |
| return delegate.properties(); |
| } |
| |
| // Languages |
| // ------------------------------------------------------------------------- |
| |
| /** |
| * Evaluates an expression using the <a |
| * href="http://camel.apache.org/bean-language.html>bean language</a> |
| * which basically means the bean is invoked to determine the expression |
| * value. |
| * |
| * @param bean the name of the bean looked up the registry |
| * @return the builder to continue processing the DSL |
| */ |
| public T method(String bean) { |
| return delegate.method(bean); |
| } |
| |
| /** |
| * Evaluates an expression using the <a |
| * href="http://camel.apache.org/bean-language.html>bean language</a> |
| * which basically means the bean is invoked to determine the expression |
| * value. |
| * |
| * @param instance the instance of the bean |
| * @return the builder to continue processing the DSL |
| */ |
| public T method(Object instance) { |
| return delegate.method(instance); |
| } |
| |
| /** |
| * Evaluates an expression using the <a |
| * href="http://camel.apache.org/bean-language.html>bean language</a> |
| * which basically means the bean is invoked to determine the expression |
| * value. |
| * |
| * @param beanType the Class of the bean which we want to invoke |
| * @return the builder to continue processing the DSL |
| */ |
| public T method(Class<?> beanType) { |
| return delegate.method(beanType); |
| } |
| |
| /** |
| * Evaluates an expression using the <a |
| * href="http://camel.apache.org/bean-language.html>bean language</a> |
| * which basically means the bean is invoked to determine the expression |
| * value. |
| * |
| * @param bean the name of the bean looked up the registry |
| * @param method the name of the method to invoke on the bean |
| * @return the builder to continue processing the DSL |
| */ |
| public T method(String bean, String method) { |
| return delegate.method(bean, method); |
| } |
| |
| /** |
| * Evaluates an expression using the <a |
| * href="http://camel.apache.org/bean-language.html>bean language</a> |
| * which basically means the bean is invoked to determine the expression |
| * value. |
| * |
| * @param instance the instance of the bean |
| * @param method the name of the method to invoke on the bean |
| * @return the builder to continue processing the DSL |
| */ |
| public T method(Object instance, String method) { |
| return delegate.method(instance, method); |
| } |
| |
| /** |
| * Evaluates an expression using the <a |
| * href="http://camel.apache.org/bean-language.html>bean language</a> |
| * which basically means the bean is invoked to determine the expression |
| * value. |
| * |
| * @param beanType the Class of the bean which we want to invoke |
| * @param method the name of the method to invoke on the bean |
| * @return the builder to continue processing the DSL |
| */ |
| public T method(Class<?> beanType, String method) { |
| return delegate.method(beanType, method); |
| } |
| |
| /** |
| * Evaluates the <a href="http://camel.apache.org/el.html">EL |
| * Language from JSP and JSF</a> using the <a |
| * href="http://camel.apache.org/juel.html">JUEL library</a> |
| * |
| * @param text the expression to be evaluated |
| * @return the builder to continue processing the DSL |
| */ |
| public T el(String text) { |
| return delegate.el(text); |
| } |
| |
| /** |
| * Evaluates a <a href="http://camel.apache.org/groovy.html">Groovy |
| * expression</a> |
| * |
| * @param text the expression to be evaluated |
| * @return the builder to continue processing the DSL |
| */ |
| public T groovy(String text) { |
| return delegate.groovy(text); |
| } |
| |
| /** |
| * Evaluates a <a |
| * href="http://camel.apache.org/java-script.html">JavaScript |
| * expression</a> |
| * |
| * @param text the expression to be evaluated |
| * @return the builder to continue processing the DSL |
| */ |
| public T javaScript(String text) { |
| return delegate.javaScript(text); |
| } |
| |
| /** |
| * Evaluates a <a href="http://commons.apache.org/jxpath/">JXPath expression</a> |
| * |
| * @param text the expression to be evaluated |
| * @return the builder to continue processing the DSL |
| */ |
| public T jxpath(String text) { |
| return delegate.jxpath(text); |
| } |
| |
| /** |
| * Evaluates an <a href="http://camel.apache.org/ognl.html">OGNL |
| * expression</a> |
| * |
| * @param text the expression to be evaluated |
| * @return the builder to continue processing the DSL |
| */ |
| public T ognl(String text) { |
| return delegate.ognl(text); |
| } |
| |
| /** |
| * Evaluates a <a href="http://camel.apache.org/mvel.html">MVEL |
| * expression</a> |
| * |
| * @param text the expression to be evaluated |
| * @return the builder to continue processing the DSL |
| */ |
| public T mvel(String text) { |
| return delegate.mvel(text); |
| } |
| |
| /** |
| * Evaluates a <a href="http://camel.apache.org/php.html">PHP |
| * expression</a> |
| * |
| * @param text the expression to be evaluated |
| * @return the builder to continue processing the DSL |
| */ |
| public T php(String text) { |
| return delegate.php(text); |
| } |
| |
| /** |
| * Evaluates a <a href="http://camel.apache.org/python.html">Python |
| * expression</a> |
| * |
| * @param text the expression to be evaluated |
| * @return the builder to continue processing the DSL |
| */ |
| public T python(String text) { |
| return delegate.python(text); |
| } |
| |
| /** |
| * Evaluates a <a href="http://camel.apache.org/ref-language.html">Ref |
| * expression</a> |
| * |
| * @param ref refers to the expression to be evaluated |
| * @return the builder to continue processing the DSL |
| */ |
| public T ref(String ref) { |
| return delegate.ref(ref); |
| } |
| |
| /** |
| * Evaluates a <a href="http://camel.apache.org/ruby.html">Ruby |
| * expression</a> |
| * |
| * @param text the expression to be evaluated |
| * @return the builder to continue processing the DSL |
| */ |
| public T ruby(String text) { |
| return delegate.ruby(text); |
| } |
| |
| /** |
| * Evaluates an <a href="http://camel.apache.org/sql.html">SQL |
| * expression</a> |
| * |
| * @param text the expression to be evaluated |
| * @return the builder to continue processing the DSL |
| */ |
| public T sql(String text) { |
| return delegate.sql(text); |
| } |
| |
| /** |
| * Evaluates a <a href="http://camel.apache.org/spel.html">SpEL |
| * expression</a> |
| * |
| * @param text the expression to be evaluated |
| * @return the builder to continue processing the DSL |
| */ |
| public T spel(String text) { |
| return delegate.spel(text); |
| } |
| |
| /** |
| * Evaluates a <a href="http://camel.apache.org/simple.html">Simple |
| * expression</a> |
| * |
| * @param text the expression to be evaluated |
| * @return the builder to continue processing the DSL |
| */ |
| public T simple(String text) { |
| return delegate.simple(text); |
| } |
| |
| /** |
| * Evaluates a <a href="http://camel.apache.org/simple.html">Simple |
| * expression</a> |
| * |
| * @param text the expression to be evaluated |
| * @param resultType the result type |
| * @return the builder to continue processing the DSL |
| */ |
| public T simple(String text, Class<?> resultType) { |
| return delegate.simple(text, resultType); |
| } |
| |
| /** |
| * Evaluates a token expression on the message body |
| * |
| * @param token the token |
| * @return the builder to continue processing the DSL |
| */ |
| public T tokenize(String token) { |
| return delegate.tokenize(token); |
| } |
| |
| /** |
| * Evaluates a token expression on the given header |
| * |
| * @param token the token |
| * @param headerName name of header to tokenize |
| * @return the builder to continue processing the DSL |
| */ |
| public T tokenize(String token, String headerName) { |
| return delegate.tokenize(token, headerName); |
| } |
| |
| /** |
| * Evaluates a token expression on the given header |
| * |
| * @param token the token |
| * @param headerName name of header to tokenize |
| * @param regex whether the token is a regular expression or not |
| * @return the builder to continue processing the DSL |
| */ |
| public T tokenize(String token, String headerName, boolean regex) { |
| return delegate.tokenize(token, headerName, regex); |
| } |
| |
| /** |
| * Evaluates an <a href="http://camel.apache.org/xpath.html">XPath |
| * expression</a> |
| * |
| * @param text the expression to be evaluated |
| * @return the builder to continue processing the DSL |
| */ |
| public T xpath(String text) { |
| return delegate.xpath(text); |
| } |
| |
| /** |
| * Evaluates an <a href="http://camel.apache.org/xpath.html">XPath |
| * expression</a> with the specified result type |
| * |
| * @param text the expression to be evaluated |
| * @param resultType the return type expected by the expression |
| * @return the builder to continue processing the DSL |
| */ |
| public T xpath(String text, Class<?> resultType) { |
| return delegate.xpath(text, resultType); |
| } |
| |
| /** |
| * Evaluates an <a href="http://camel.apache.org/xpath.html">XPath |
| * expression</a> with the specified result type and set of namespace |
| * prefixes and URIs |
| * |
| * @param text the expression to be evaluated |
| * @param resultType the return type expected by the expression |
| * @param namespaces the namespace prefix and URIs to use |
| * @return the builder to continue processing the DSL |
| */ |
| public T xpath(String text, Class<?> resultType, Namespaces namespaces) { |
| return delegate.xpath(text, resultType, namespaces); |
| } |
| |
| /** |
| * Evaluates an <a href="http://camel.apache.org/xpath.html">XPath |
| * expression</a> with the specified result type and set of namespace |
| * prefixes and URIs |
| * |
| * @param text the expression to be evaluated |
| * @param resultType the return type expected by the expression |
| * @param namespaces the namespace prefix and URIs to use |
| * @return the builder to continue processing the DSL |
| */ |
| public T xpath(String text, Class<?> resultType, Map<String, String> namespaces) { |
| return delegate.xpath(text, resultType, namespaces); |
| } |
| |
| /** |
| * Evaluates an <a href="http://camel.apache.org/xpath.html">XPath |
| * expression</a> with the specified set of namespace prefixes and URIs |
| * |
| * @param text the expression to be evaluated |
| * @param namespaces the namespace prefix and URIs to use |
| * @return the builder to continue processing the DSL |
| */ |
| public T xpath(String text, Namespaces namespaces) { |
| return delegate.xpath(text, namespaces); |
| } |
| |
| /** |
| * Evaluates an <a href="http://camel.apache.org/xpath.html">XPath |
| * expression</a> with the specified set of namespace prefixes and URIs |
| * |
| * @param text the expression to be evaluated |
| * @param namespaces the namespace prefix and URIs to use |
| * @return the builder to continue processing the DSL |
| */ |
| public T xpath(String text, Map<String, String> namespaces) { |
| return delegate.xpath(text, namespaces); |
| } |
| |
| /** |
| * Evaluates an <a |
| * href="http://camel.apache.org/xquery.html">XQuery expression</a> |
| * |
| * @param text the expression to be evaluated |
| * @return the builder to continue processing the DSL |
| */ |
| public T xquery(String text) { |
| return delegate.xquery(text); |
| } |
| |
| /** |
| * Evaluates an <a |
| * href="http://camel.apache.org/xquery.html">XQuery expression</a> |
| * with the specified result type |
| * |
| * @param text the expression to be evaluated |
| * @param resultType the return type expected by the expression |
| * @return the builder to continue processing the DSL |
| */ |
| public T xquery(String text, Class<?> resultType) { |
| return delegate.xquery(text, resultType); |
| } |
| |
| /** |
| * Evaluates an <a |
| * href="http://camel.apache.org/xquery.html">XQuery expression</a> |
| * with the specified result type and set of namespace prefixes and URIs |
| * |
| * @param text the expression to be evaluated |
| * @param resultType the return type expected by the expression |
| * @param namespaces the namespace prefix and URIs to use |
| * @return the builder to continue processing the DSL |
| */ |
| public T xquery(String text, Class<?> resultType, Namespaces namespaces) { |
| return delegate.xquery(text, resultType, namespaces); |
| } |
| |
| /** |
| * Evaluates an <a |
| * href="http://camel.apache.org/xquery.html">XQuery expression</a> |
| * with the specified result type and set of namespace prefixes and URIs |
| * |
| * @param text the expression to be evaluated |
| * @param resultType the return type expected by the expression |
| * @param namespaces the namespace prefix and URIs to use |
| * @return the builder to continue processing the DSL |
| */ |
| public T xquery(String text, Class<?> resultType, Map<String, String> namespaces) { |
| return delegate.xquery(text, resultType, namespaces); |
| } |
| |
| /** |
| * Evaluates an <a |
| * href="http://camel.apache.org/xquery.html">XQuery expression</a> |
| * with the specified set of namespace prefixes and URIs |
| * |
| * @param text the expression to be evaluated |
| * @param namespaces the namespace prefix and URIs to use |
| * @return the builder to continue processing the DSL |
| */ |
| public T xquery(String text, Namespaces namespaces) { |
| return delegate.xquery(text, namespaces); |
| } |
| |
| /** |
| * Evaluates an <a |
| * href="http://camel.apache.org/xquery.html">XQuery expression</a> |
| * with the specified set of namespace prefixes and URIs |
| * |
| * @param text the expression to be evaluated |
| * @param namespaces the namespace prefix and URIs to use |
| * @return the builder to continue processing the DSL |
| */ |
| public T xquery(String text, Map<String, String> namespaces) { |
| return delegate.xquery(text, namespaces); |
| } |
| |
| /** |
| * Evaluates a given language name with the expression text |
| * |
| * @param language the name of the language |
| * @param expression the expression in the given language |
| * @return the builder to continue processing the DSL |
| */ |
| public T language(String language, String expression) { |
| return delegate.language(language, expression); |
| } |
| |
| // Properties |
| // ------------------------------------------------------------------------- |
| |
| |
| @Override |
| public String getLanguage() { |
| return delegate.getLanguage(); |
| } |
| |
| @Override |
| public String getExpression() { |
| return delegate.getExpression(); |
| } |
| |
| @Override |
| public void setExpression(String expression) { |
| delegate.setExpression(expression); |
| } |
| |
| @Override |
| public Expression getExpressionValue() { |
| return delegate.getExpressionValue(); |
| } |
| |
| @Override |
| protected void setExpressionValue(Expression expressionValue) { |
| delegate.setExpressionValue(expressionValue); |
| } |
| |
| @Override |
| public ExpressionDefinition getExpressionType() { |
| return delegate.getExpressionType(); |
| } |
| |
| @Override |
| protected void setExpressionType(ExpressionDefinition expressionType) { |
| delegate.setExpressionType(expressionType); |
| } |
| } |