001 /** 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.camel.builder; 018 019 import java.util.Map; 020 021 import org.apache.camel.Expression; 022 import org.apache.camel.builder.xml.Namespaces; 023 import org.apache.camel.model.ExpressionNode; 024 import org.apache.camel.model.language.ExpressionDefinition; 025 import org.apache.camel.model.language.MethodCallExpression; 026 import org.apache.camel.model.language.XPathExpression; 027 import org.apache.camel.model.language.XQueryExpression; 028 029 /** 030 * Represents an expression clause within the DSL which when the expression is 031 * complete the clause continues to another part of the DSL 032 * 033 * @version $Revision: 775155 $ 034 */ 035 public class ExpressionClause<T> extends ExpressionDefinition { 036 private T result; 037 private String language; 038 039 public ExpressionClause(T result) { 040 this.result = result; 041 } 042 043 public static <T extends ExpressionNode> ExpressionClause<T> createAndSetExpression(T result) { 044 ExpressionClause<T> clause = new ExpressionClause<T>(result); 045 result.setExpression(clause); 046 return clause; 047 } 048 049 // Helper expressions 050 // ------------------------------------------------------------------------- 051 052 /** 053 * Specify an {@link Expression} instance 054 */ 055 public T expression(Expression expression) { 056 setExpressionValue(expression); 057 return result; 058 } 059 060 /** 061 * Specify the constant expression value 062 */ 063 public T constant(Object value) { 064 return expression(ExpressionBuilder.constantExpression(value)); 065 } 066 067 /** 068 * An expression of the exchange 069 */ 070 public T exchange() { 071 return expression(ExpressionBuilder.exchangeExpression()); 072 } 073 074 /** 075 * An expression of an inbound message 076 */ 077 public T inMessage() { 078 return expression(ExpressionBuilder.inMessageExpression()); 079 } 080 081 /** 082 * An expression of an inbound message 083 */ 084 public T outMessage() { 085 return expression(ExpressionBuilder.outMessageExpression()); 086 } 087 088 /** 089 * An expression of an inbound message body 090 */ 091 public T body() { 092 return expression(ExpressionBuilder.bodyExpression()); 093 } 094 095 /** 096 * An expression of an inbound message body converted to the expected type 097 */ 098 public T body(Class expectedType) { 099 return expression(ExpressionBuilder.bodyExpression(expectedType)); 100 } 101 102 /** 103 * An expression of an outbound message body 104 */ 105 public T outBody() { 106 return expression(ExpressionBuilder.outBodyExpression()); 107 } 108 109 /** 110 * An expression of an outbound message body converted to the expected type 111 */ 112 @SuppressWarnings("unchecked") 113 public T outBody(Class expectedType) { 114 return expression(ExpressionBuilder.outBodyExpression(expectedType)); 115 } 116 117 /** 118 * An expression of an inbound message header of the given name 119 */ 120 public T header(String name) { 121 return expression(ExpressionBuilder.headerExpression(name)); 122 } 123 124 /** 125 * An expression of the inbound headers 126 */ 127 public T headers() { 128 return expression(ExpressionBuilder.headersExpression()); 129 } 130 131 /** 132 * An expression of an outbound message header of the given name 133 */ 134 public T outHeader(String name) { 135 return expression(ExpressionBuilder.outHeaderExpression(name)); 136 } 137 138 /** 139 * An expression of the outbound headers 140 */ 141 public T outHeaders() { 142 return expression(ExpressionBuilder.outHeadersExpression()); 143 } 144 145 /** 146 * An expression of an exchange property of the given name 147 */ 148 public T property(String name) { 149 return expression(ExpressionBuilder.propertyExpression(name)); 150 } 151 152 /** 153 * An expression of the exchange properties 154 */ 155 public T properties() { 156 return expression(ExpressionBuilder.propertiesExpression()); 157 } 158 159 // Languages 160 // ------------------------------------------------------------------------- 161 162 /** 163 * Evaluates an expression using the <a 164 * href="http://camel.apache.org/bean-language.html>bean language</a> 165 * which basically means the bean is invoked to determine the expression 166 * value. 167 * 168 * @param bean the name of the bean looked up the registry 169 * @return the builder to continue processing the DSL 170 */ 171 public T method(String bean) { 172 MethodCallExpression expression = new MethodCallExpression(bean); 173 setExpressionType(expression); 174 return result; 175 } 176 177 /** 178 * Evaluates an expression using the <a 179 * href="http://camel.apache.org/bean-language.html>bean language</a> 180 * which basically means the bean is invoked to determine the expression 181 * value. 182 * 183 * @param beanType the Class of the bean which we want to invoke 184 * @return the builder to continue processing the DSL 185 */ 186 public T method(Class beanType) { 187 MethodCallExpression expression = new MethodCallExpression(beanType); 188 setExpressionType(expression); 189 return result; 190 } 191 192 /** 193 * Evaluates an expression using the <a 194 * href="http://camel.apache.org/bean-language.html>bean language</a> 195 * which basically means the bean is invoked to determine the expression 196 * value. 197 * 198 * @param bean the name of the bean looked up the registry 199 * @param method the name of the method to invoke on the bean 200 * @return the builder to continue processing the DSL 201 */ 202 public T method(String bean, String method) { 203 MethodCallExpression expression = new MethodCallExpression(bean, method); 204 setExpressionType(expression); 205 return result; 206 } 207 208 /** 209 * Evaluates an expression using the <a 210 * href="http://camel.apache.org/bean-language.html>bean language</a> 211 * which basically means the bean is invoked to determine the expression 212 * value. 213 * 214 * @param beanType the Class of the bean which we want to invoke 215 * @param method the name of the method to invoke on the bean 216 * @return the builder to continue processing the DSL 217 */ 218 public T method(Class beanType, String method) { 219 MethodCallExpression expression = new MethodCallExpression(beanType, method); 220 setExpressionType(expression); 221 return result; 222 } 223 224 /** 225 * Evaluates the <a href="http://camel.apache.org/el.html">EL 226 * Language from JSP and JSF</a> using the <a 227 * href="http://camel.apache.org/juel.html">JUEL library</a> 228 * 229 * @param text the expression to be evaluated 230 * @return the builder to continue processing the DSL 231 */ 232 public T el(String text) { 233 return language("el", text); 234 } 235 236 /** 237 * Evaluates a <a href="http://camel.apache.org/groovy.html">Groovy 238 * expression</a> 239 * 240 * @param text the expression to be evaluated 241 * @return the builder to continue processing the DSL 242 */ 243 public T groovy(String text) { 244 return language("groovy", text); 245 } 246 247 /** 248 * Evaluates a <a 249 * href="http://camel.apache.org/java-script.html">JavaScript 250 * expression</a> 251 * 252 * @param text the expression to be evaluated 253 * @return the builder to continue processing the DSL 254 */ 255 public T javaScript(String text) { 256 return language("js", text); 257 } 258 259 /** 260 * Evaluates a <a href="http://commons.apache.org/jxpath/">JXPath expression</a> 261 * 262 * @param text the expression to be evaluated 263 * @return the builder to continue processing the DSL 264 */ 265 public T jxpath(String text) { 266 return language("jxpath", text); 267 } 268 269 /** 270 * Evaluates an <a href="http://camel.apache.org/ognl.html">OGNL 271 * expression</a> 272 * 273 * @param text the expression to be evaluated 274 * @return the builder to continue processing the DSL 275 */ 276 public T ognl(String text) { 277 return language("ognl", text); 278 } 279 280 /** 281 * Evaluates a <a href="http://camel.apache.org/mvel.html">MVEL 282 * expression</a> 283 * 284 * @param text the expression to be evaluated 285 * @return the builder to continue processing the DSL 286 */ 287 public T mvel(String text) { 288 return language("mvel", text); 289 } 290 291 /** 292 * Evaluates a <a href="http://camel.apache.org/php.html">PHP 293 * expression</a> 294 * 295 * @param text the expression to be evaluated 296 * @return the builder to continue processing the DSL 297 */ 298 public T php(String text) { 299 return language("php", text); 300 } 301 302 /** 303 * Evaluates a <a href="http://camel.apache.org/python.html">Python 304 * expression</a> 305 * 306 * @param text the expression to be evaluated 307 * @return the builder to continue processing the DSL 308 */ 309 public T python(String text) { 310 return language("python", text); 311 } 312 313 /** 314 * Evaluates a <a href="http://camel.apache.org/ruby.html">Ruby 315 * expression</a> 316 * 317 * @param text the expression to be evaluated 318 * @return the builder to continue processing the DSL 319 */ 320 public T ruby(String text) { 321 return language("ruby", text); 322 } 323 324 /** 325 * Evaluates an <a href="http://camel.apache.org/sql.html">SQL 326 * expression</a> 327 * 328 * @param text the expression to be evaluated 329 * @return the builder to continue processing the DSL 330 */ 331 public T sql(String text) { 332 return language("sql", text); 333 } 334 335 /** 336 * Evaluates a <a href="http://camel.apache.org/simple.html">Simple 337 * expression</a> 338 * 339 * @param text the expression to be evaluated 340 * @return the builder to continue processing the DSL 341 */ 342 public T simple(String text) { 343 return language("simple", text); 344 } 345 346 /** 347 * Evaluates an <a href="http://camel.apache.org/xpath.html">XPath 348 * expression</a> 349 * 350 * @param text the expression to be evaluated 351 * @return the builder to continue processing the DSL 352 */ 353 public T xpath(String text) { 354 return language("xpath", text); 355 } 356 357 /** 358 * Evaluates an <a href="http://camel.apache.org/xpath.html">XPath 359 * expression</a> with the specified result type 360 * 361 * @param text the expression to be evaluated 362 * @param resultType the return type expected by the expressiopn 363 * @return the builder to continue processing the DSL 364 */ 365 public T xpath(String text, Class resultType) { 366 XPathExpression expression = new XPathExpression(text); 367 expression.setResultType(resultType); 368 setExpressionType(expression); 369 return result; 370 } 371 372 /** 373 * Evaluates an <a href="http://camel.apache.org/xpath.html">XPath 374 * expression</a> with the specified result type and set of namespace 375 * prefixes and URIs 376 * 377 * @param text the expression to be evaluated 378 * @param resultType the return type expected by the expression 379 * @param namespaces the namespace prefix and URIs to use 380 * @return the builder to continue processing the DSL 381 */ 382 public T xpath(String text, Class resultType, Namespaces namespaces) { 383 return xpath(text, resultType, namespaces.getNamespaces()); 384 } 385 386 /** 387 * Evaluates an <a href="http://camel.apache.org/xpath.html">XPath 388 * expression</a> with the specified result type and set of namespace 389 * prefixes and URIs 390 * 391 * @param text the expression to be evaluated 392 * @param resultType the return type expected by the expression 393 * @param namespaces the namespace prefix and URIs to use 394 * @return the builder to continue processing the DSL 395 */ 396 public T xpath(String text, Class resultType, Map<String, String> namespaces) { 397 XPathExpression expression = new XPathExpression(text); 398 expression.setResultType(resultType); 399 expression.setNamespaces(namespaces); 400 setExpressionType(expression); 401 return result; 402 } 403 404 /** 405 * Evaluates an <a href="http://camel.apache.org/xpath.html">XPath 406 * expression</a> with the specified set of namespace prefixes and URIs 407 * 408 * @param text the expression to be evaluated 409 * @param namespaces the namespace prefix and URIs to use 410 * @return the builder to continue processing the DSL 411 */ 412 public T xpath(String text, Namespaces namespaces) { 413 return xpath(text, namespaces.getNamespaces()); 414 } 415 416 /** 417 * Evaluates an <a href="http://camel.apache.org/xpath.html">XPath 418 * expression</a> with the specified set of namespace prefixes and URIs 419 * 420 * @param text the expression to be evaluated 421 * @param namespaces the namespace prefix and URIs to use 422 * @return the builder to continue processing the DSL 423 */ 424 public T xpath(String text, Map<String, String> namespaces) { 425 XPathExpression expression = new XPathExpression(text); 426 expression.setNamespaces(namespaces); 427 setExpressionType(expression); 428 return result; 429 } 430 431 /** 432 * Evaluates an <a 433 * href="http://camel.apache.org/xquery.html">XQuery expression</a> 434 * 435 * @param text the expression to be evaluated 436 * @return the builder to continue processing the DSL 437 */ 438 public T xquery(String text) { 439 return language("xquery", text); 440 } 441 442 /** 443 * Evaluates an <a 444 * href="http://camel.apache.org/xquery.html">XQuery expression</a> 445 * with the specified result type 446 * 447 * @param text the expression to be evaluated 448 * @param resultType the return type expected by the expressiopn 449 * @return the builder to continue processing the DSL 450 */ 451 public T xquery(String text, Class resultType) { 452 XQueryExpression expression = new XQueryExpression(text); 453 expression.setResultType(resultType); 454 setExpressionType(expression); 455 return result; 456 } 457 458 /** 459 * Evaluates an <a 460 * href="http://camel.apache.org/xquery.html">XQuery expression</a> 461 * with the specified result type and set of namespace prefixes and URIs 462 * 463 * @param text the expression to be evaluated 464 * @param resultType the return type expected by the expression 465 * @param namespaces the namespace prefix and URIs to use 466 * @return the builder to continue processing the DSL 467 */ 468 public T xquery(String text, Class resultType, Namespaces namespaces) { 469 return xquery(text, resultType, namespaces.getNamespaces()); 470 } 471 472 /** 473 * Evaluates an <a 474 * href="http://camel.apache.org/xquery.html">XQuery expression</a> 475 * with the specified result type and set of namespace prefixes and URIs 476 * 477 * @param text the expression to be evaluated 478 * @param resultType the return type expected by the expression 479 * @param namespaces the namespace prefix and URIs to use 480 * @return the builder to continue processing the DSL 481 */ 482 public T xquery(String text, Class resultType, Map<String, String> namespaces) { 483 XQueryExpression expression = new XQueryExpression(text); 484 expression.setResultType(resultType); 485 expression.setNamespaces(namespaces); 486 setExpressionType(expression); 487 return result; 488 } 489 490 /** 491 * Evaluates an <a 492 * href="http://camel.apache.org/xquery.html">XQuery expression</a> 493 * with the specified set of namespace prefixes and URIs 494 * 495 * @param text the expression to be evaluated 496 * @param namespaces the namespace prefix and URIs to use 497 * @return the builder to continue processing the DSL 498 */ 499 public T xquery(String text, Namespaces namespaces) { 500 return xquery(text, namespaces.getNamespaces()); 501 } 502 503 /** 504 * Evaluates an <a 505 * href="http://camel.apache.org/xquery.html">XQuery expression</a> 506 * with the specified set of namespace prefixes and URIs 507 * 508 * @param text the expression to be evaluated 509 * @param namespaces the namespace prefix and URIs to use 510 * @return the builder to continue processing the DSL 511 */ 512 public T xquery(String text, Map<String, String> namespaces) { 513 XQueryExpression expression = new XQueryExpression(text); 514 expression.setNamespaces(namespaces); 515 setExpressionType(expression); 516 return result; 517 } 518 519 /** 520 * Evaluates a given language name with the expression text 521 * 522 * @param language the name of the language 523 * @param expression the expression in the given language 524 * @return the builder to continue processing the DSL 525 */ 526 public T language(String language, String expression) { 527 setLanguage(language); 528 setExpression(expression); 529 return result; 530 } 531 532 // Properties 533 // ------------------------------------------------------------------------- 534 public String getLanguage() { 535 return language; 536 } 537 538 public void setLanguage(String language) { 539 this.language = language; 540 } 541 }