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.ArrayList; 020 import java.util.Arrays; 021 import java.util.Collection; 022 import java.util.List; 023 import java.util.StringTokenizer; 024 import java.util.regex.Pattern; 025 026 import org.apache.camel.Exchange; 027 import org.apache.camel.Expression; 028 import org.apache.camel.Message; 029 030 /** 031 * @version $Revision: 37863 $ 032 */ 033 public final class ExpressionBuilder { 034 035 036 /** 037 * Utility classes should not have a public constructor. 038 */ 039 private ExpressionBuilder() { 040 } 041 042 /** 043 * Returns an expression for the header value with the given name 044 * 045 * @param headerName the name of the header the expression will return 046 * @return an expression object which will return the header value 047 */ 048 public static <E extends Exchange> Expression<E> headerExpression(final String headerName) { 049 return new Expression<E>() { 050 public Object evaluate(E exchange) { 051 Object header = exchange.getIn().getHeader(headerName); 052 if (header == null) { 053 // lets try the exchange header 054 header = exchange.getProperty(headerName); 055 } 056 return header; 057 } 058 059 @Override 060 public String toString() { 061 return "header(" + headerName + ")"; 062 } 063 }; 064 } 065 066 /** 067 * Returns an expression for the inbound message headers 068 * 069 * @see Message#getHeaders() 070 * @return an expression object which will return the inbound headers 071 */ 072 public static <E extends Exchange> Expression<E> headersExpression() { 073 return new Expression<E>() { 074 public Object evaluate(E exchange) { 075 return exchange.getIn().getHeaders(); 076 } 077 078 @Override 079 public String toString() { 080 return "headers"; 081 } 082 }; 083 } 084 085 /** 086 * Returns an expression for the out header value with the given name 087 * 088 * @param headerName the name of the header the expression will return 089 * @return an expression object which will return the header value 090 */ 091 public static <E extends Exchange> Expression<E> outHeaderExpression(final String headerName) { 092 return new Expression<E>() { 093 public Object evaluate(E exchange) { 094 Message out = exchange.getOut(false); 095 if (out == null) { 096 return null; 097 } 098 Object header = out.getHeader(headerName); 099 if (header == null) { 100 // lets try the exchange header 101 header = exchange.getProperty(headerName); 102 } 103 return header; 104 } 105 106 @Override 107 public String toString() { 108 return "outHeader(" + headerName + ")"; 109 } 110 }; 111 } 112 113 /** 114 * Returns an expression for the outbound message headers 115 * 116 * @see Message#getHeaders() 117 * @return an expression object which will return the inbound headers 118 */ 119 public static <E extends Exchange> Expression<E> outHeadersExpression() { 120 return new Expression<E>() { 121 public Object evaluate(E exchange) { 122 return exchange.getOut().getHeaders(); 123 } 124 125 @Override 126 public String toString() { 127 return "outHeaders"; 128 } 129 }; 130 } 131 132 /** 133 * Returns an expression for the property value with the given name 134 * 135 * @see Exchange#getProperty(String) 136 * @param propertyName the name of the property the expression will return 137 * @return an expression object which will return the property value 138 */ 139 public static <E extends Exchange> Expression<E> propertyExpression(final String propertyName) { 140 return new Expression<E>() { 141 public Object evaluate(E exchange) { 142 return exchange.getProperty(propertyName); 143 } 144 145 @Override 146 public String toString() { 147 return "property(" + propertyName + ")"; 148 } 149 }; 150 } 151 152 153 /** 154 * Returns an expression for the property value with the given name 155 * 156 * @see Exchange#getProperties() 157 * @return an expression object which will return the properties 158 */ 159 public static <E extends Exchange> Expression<E> propertiesExpression() { 160 return new Expression<E>() { 161 public Object evaluate(E exchange) { 162 return exchange.getProperties(); 163 } 164 165 @Override 166 public String toString() { 167 return "properties"; 168 } 169 }; 170 } 171 172 /** 173 * Returns an expression for a system property value with the given name 174 * 175 * @param propertyName the name of the system property the expression will 176 * return 177 * @return an expression object which will return the system property value 178 */ 179 public static <E extends Exchange> Expression<E> systemPropertyExpression(final String propertyName) { 180 return systemPropertyExpression(propertyName, null); 181 } 182 183 /** 184 * Returns an expression for a system property value with the given name 185 * 186 * @param propertyName the name of the system property the expression will 187 * return 188 * @return an expression object which will return the system property value 189 */ 190 public static <E extends Exchange> Expression<E> systemPropertyExpression(final String propertyName, 191 final String defaultValue) { 192 return new Expression<E>() { 193 public Object evaluate(E exchange) { 194 return System.getProperty(propertyName, defaultValue); 195 } 196 197 @Override 198 public String toString() { 199 return "systemProperty(" + propertyName + ")"; 200 } 201 }; 202 } 203 204 /** 205 * Returns an expression for the constant value 206 * 207 * @param value the value the expression will return 208 * @return an expression object which will return the constant value 209 */ 210 public static <E extends Exchange> Expression<E> constantExpression(final Object value) { 211 return new Expression<E>() { 212 public Object evaluate(E exchange) { 213 return value; 214 } 215 216 @Override 217 public String toString() { 218 return "" + value; 219 } 220 }; 221 } 222 223 /** 224 * Returns the expression for the exchanges inbound message body 225 */ 226 public static <E extends Exchange> Expression<E> bodyExpression() { 227 return new Expression<E>() { 228 public Object evaluate(E exchange) { 229 return exchange.getIn().getBody(); 230 } 231 232 @Override 233 public String toString() { 234 return "body"; 235 } 236 }; 237 } 238 239 /** 240 * Returns the expression for the exchanges inbound message body converted 241 * to the given type 242 */ 243 public static <E extends Exchange, T> Expression<E> bodyExpression(final Class<T> type) { 244 return new Expression<E>() { 245 public Object evaluate(E exchange) { 246 return exchange.getIn().getBody(type); 247 } 248 249 @Override 250 public String toString() { 251 return "bodyAs[" + type.getName() + "]"; 252 } 253 }; 254 } 255 256 /** 257 * Returns the expression for the out messages body 258 */ 259 public static <E extends Exchange> Expression<E> outBodyExpression() { 260 return new Expression<E>() { 261 public Object evaluate(E exchange) { 262 Message out = exchange.getOut(false); 263 if (out == null) { 264 return null; 265 } 266 return out.getBody(); 267 } 268 269 @Override 270 public String toString() { 271 return "outBody"; 272 } 273 }; 274 } 275 276 /** 277 * Returns the expression for the exchanges outbound message body converted 278 * to the given type 279 */ 280 public static <E extends Exchange, T> Expression<E> outBodyExpression(final Class<T> type) { 281 return new Expression<E>() { 282 public Object evaluate(E exchange) { 283 Message out = exchange.getOut(false); 284 if (out == null) { 285 return null; 286 } 287 return out.getBody(type); 288 } 289 290 @Override 291 public String toString() { 292 return "outBodyAs[" + type.getName() + "]"; 293 } 294 }; 295 } 296 297 /** 298 * Returns the expression for the fault messages body 299 */ 300 public static <E extends Exchange> Expression<E> faultBodyExpression() { 301 return new Expression<E>() { 302 public Object evaluate(E exchange) { 303 return exchange.getFault().getBody(); 304 } 305 306 @Override 307 public String toString() { 308 return "faultBody"; 309 } 310 }; 311 } 312 313 /** 314 * Returns the expression for the exchanges fault message body converted 315 * to the given type 316 */ 317 public static <E extends Exchange, T> Expression<E> faultBodyExpression(final Class<T> type) { 318 return new Expression<E>() { 319 public Object evaluate(E exchange) { 320 return exchange.getFault().getBody(type); 321 } 322 323 @Override 324 public String toString() { 325 return "faultBodyAs[" + type.getName() + "]"; 326 } 327 }; 328 } 329 330 /** 331 * Returns the expression for the exchange 332 */ 333 public static <E extends Exchange> Expression<E> exchangeExpression() { 334 return new Expression<E>() { 335 public Object evaluate(E exchange) { 336 return exchange; 337 } 338 339 @Override 340 public String toString() { 341 return "exchange"; 342 } 343 }; 344 } 345 346 /** 347 * Returns the expression for the IN message 348 */ 349 public static <E extends Exchange> Expression<E> inMessageExpression() { 350 return new Expression<E>() { 351 public Object evaluate(E exchange) { 352 return exchange.getIn(); 353 } 354 355 @Override 356 public String toString() { 357 return "inMessage"; 358 } 359 }; 360 } 361 362 /** 363 * Returns the expression for the OUT message 364 */ 365 public static <E extends Exchange> Expression<E> outMessageExpression() { 366 return new Expression<E>() { 367 public Object evaluate(E exchange) { 368 return exchange.getOut(); 369 } 370 371 @Override 372 public String toString() { 373 return "outMessage"; 374 } 375 }; 376 } 377 378 /** 379 * Returns an expression which converts the given expression to the given 380 * type 381 */ 382 public static <E extends Exchange> Expression<E> convertTo(final Expression expression, final Class type) { 383 return new Expression<E>() { 384 public Object evaluate(E exchange) { 385 Object value = expression.evaluate(exchange); 386 return exchange.getContext().getTypeConverter().convertTo(type, value); 387 } 388 389 @Override 390 public String toString() { 391 return "" + expression + ".convertTo(" + type.getName() + ".class)"; 392 } 393 }; 394 } 395 396 /** 397 * Returns a tokenize expression which will tokenize the string with the 398 * given token 399 */ 400 public static <E extends Exchange> Expression<E> tokenizeExpression(final Expression<E> expression, 401 final String token) { 402 return new Expression<E>() { 403 public Object evaluate(E exchange) { 404 String text = evaluateStringExpression(expression, exchange); 405 if (text == null) { 406 return null; 407 } 408 StringTokenizer iter = new StringTokenizer(text, token); 409 List<String> answer = new ArrayList<String>(); 410 while (iter.hasMoreTokens()) { 411 answer.add(iter.nextToken()); 412 } 413 return answer; 414 } 415 416 @Override 417 public String toString() { 418 return "tokenize(" + expression + ", " + token + ")"; 419 } 420 }; 421 } 422 423 /** 424 * Returns a tokenize expression which will tokenize the string with the 425 * given regex 426 */ 427 public static <E extends Exchange> Expression<E> regexTokenize(final Expression<E> expression, 428 String regexTokenizer) { 429 final Pattern pattern = Pattern.compile(regexTokenizer); 430 return new Expression<E>() { 431 public Object evaluate(E exchange) { 432 String text = evaluateStringExpression(expression, exchange); 433 if (text == null) { 434 return null; 435 } 436 return Arrays.asList(pattern.split(text)); 437 } 438 439 @Override 440 public String toString() { 441 return "regexTokenize(" + expression + ", " + pattern.pattern() + ")"; 442 } 443 }; 444 } 445 446 /** 447 * Transforms the expression into a String then performs the regex 448 * replaceAll to transform the String and return the result 449 */ 450 public static <E extends Exchange> Expression<E> regexReplaceAll(final Expression<E> expression, 451 String regex, final String replacement) { 452 final Pattern pattern = Pattern.compile(regex); 453 return new Expression<E>() { 454 public Object evaluate(E exchange) { 455 String text = evaluateStringExpression(expression, exchange); 456 if (text == null) { 457 return null; 458 } 459 return pattern.matcher(text).replaceAll(replacement); 460 } 461 462 @Override 463 public String toString() { 464 return "regexReplaceAll(" + expression + ", " + pattern.pattern() + ")"; 465 } 466 }; 467 } 468 469 /** 470 * Transforms the expression into a String then performs the regex 471 * replaceAll to transform the String and return the result 472 */ 473 public static <E extends Exchange> Expression<E> regexReplaceAll(final Expression<E> expression, 474 String regex, 475 final Expression<E> replacementExpression) { 476 final Pattern pattern = Pattern.compile(regex); 477 return new Expression<E>() { 478 public Object evaluate(E exchange) { 479 String text = evaluateStringExpression(expression, exchange); 480 String replacement = evaluateStringExpression(replacementExpression, exchange); 481 if (text == null || replacement == null) { 482 return null; 483 } 484 return pattern.matcher(text).replaceAll(replacement); 485 } 486 487 @Override 488 public String toString() { 489 return "regexReplaceAll(" + expression + ", " + pattern.pattern() + ")"; 490 } 491 }; 492 } 493 494 /** 495 * Appends the String evaluations of the two expressions together 496 */ 497 public static <E extends Exchange> Expression<E> append(final Expression<E> left, 498 final Expression<E> right) { 499 return new Expression<E>() { 500 public Object evaluate(E exchange) { 501 return evaluateStringExpression(left, exchange) + evaluateStringExpression(right, exchange); 502 } 503 504 @Override 505 public String toString() { 506 return "append(" + left + ", " + right + ")"; 507 } 508 }; 509 } 510 511 /** 512 * Evaluates the expression on the given exchange and returns the String 513 * representation 514 * 515 * @param expression the expression to evaluate 516 * @param exchange the exchange to use to evaluate the expression 517 * @return the String representation of the expression or null if it could 518 * not be evaluated 519 */ 520 public static <E extends Exchange> String evaluateStringExpression(Expression<E> expression, E exchange) { 521 Object value = expression.evaluate(exchange); 522 return exchange.getContext().getTypeConverter().convertTo(String.class, value); 523 } 524 525 /** 526 * Returns an expression for the given system property 527 */ 528 public static <E extends Exchange> Expression<E> systemProperty(final String name) { 529 return systemProperty(name, null); 530 } 531 532 /** 533 * Returns an expression for the given system property 534 */ 535 public static <E extends Exchange> Expression<E> systemProperty(final String name, 536 final String defaultValue) { 537 return new Expression<E>() { 538 public Object evaluate(E exchange) { 539 return System.getProperty(name, defaultValue); 540 } 541 }; 542 } 543 544 /** 545 * Returns an expression which returns the string concatenation value of the various 546 * expressions 547 * 548 * @param expressions the expression to be concatenated dynamically 549 * @return an expression which when evaluated will return the concatenated values 550 */ 551 public static <E extends Exchange> Expression<E> concatExpression(final Collection<Expression> expressions) { 552 return concatExpression(expressions, null); 553 } 554 555 /** 556 * Returns an expression which returns the string concatenation value of the various 557 * expressions 558 * 559 * @param expressions the expression to be concatenated dynamically 560 * @param expression the text description of the expression 561 * @return an expression which when evaluated will return the concatenated values 562 */ 563 public static <E extends Exchange> Expression<E> concatExpression(final Collection<Expression> expressions, final String expression) { 564 return new Expression<E>() { 565 public Object evaluate(E exchange) { 566 StringBuffer buffer = new StringBuffer(); 567 for (Expression<E> expression : expressions) { 568 String text = evaluateStringExpression(expression, exchange); 569 if (text != null) { 570 buffer.append(text); 571 } 572 } 573 return buffer.toString(); 574 } 575 576 @Override 577 public String toString() { 578 if (expression != null) { 579 return expression; 580 } else { 581 return "concat" + expressions; 582 } 583 } 584 }; 585 } 586 }