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 org.apache.camel.Exchange; 020 import org.apache.camel.Expression; 021 022 import java.util.ArrayList; 023 import java.util.List; 024 import java.util.StringTokenizer; 025 import java.util.Arrays; 026 import java.util.regex.Pattern; 027 028 /** 029 * @version $Revision: $ 030 */ 031 public class ExpressionBuilder { 032 033 034 /** 035 * Returns an expression for the header value with the given name 036 * 037 * @param headerName the name of the header the expression will return 038 * @return an expression object which will return the header value 039 */ 040 public static <E extends Exchange> Expression<E> headerExpression(final String headerName) { 041 return new Expression<E>() { 042 public Object evaluate(E exchange) { 043 Object header = exchange.getIn().getHeader(headerName); 044 if (header == null) { 045 // lets try the exchange header 046 header = exchange.getProperty(headerName); 047 } 048 return header; 049 } 050 051 052 @Override 053 public String toString() { 054 return "header(" + headerName + ")"; 055 } 056 }; 057 } 058 059 /** 060 * Returns an expression for the property value with the given name 061 * 062 * @param propertyName the name of the property the expression will return 063 * @return an expression object which will return the property value 064 */ 065 public static <E extends Exchange> Expression<E> propertyExpression(final String propertyName) { 066 return new Expression<E>() { 067 public Object evaluate(E exchange) { 068 return exchange.getProperty(propertyName); 069 } 070 071 @Override 072 public String toString() { 073 return "property(" + propertyName + ")"; 074 } 075 }; 076 } 077 078 /** 079 * Returns an expression for the contant value 080 * 081 * @param value the value the expression will return 082 * @return an expression object which will return the constant value 083 */ 084 public static <E extends Exchange> Expression<E> constantExpression(final Object value) { 085 return new Expression<E>() { 086 public Object evaluate(E exchange) { 087 return value; 088 } 089 090 @Override 091 public String toString() { 092 return "" + value; 093 } 094 }; 095 } 096 097 /** 098 * Returns the expression for the exchanges inbound message body 099 */ 100 public static <E extends Exchange> Expression<E> bodyExpression() { 101 return new Expression<E>() { 102 public Object evaluate(E exchange) { 103 return exchange.getIn().getBody(); 104 } 105 106 @Override 107 public String toString() { 108 return "body"; 109 } 110 }; 111 } 112 113 114 /** 115 * Returns the expression for the exchanges inbound message body converted to the given type 116 */ 117 public static <E extends Exchange, T> Expression<E> bodyExpression(final Class<T> type) { 118 return new Expression<E>() { 119 public Object evaluate(E exchange) { 120 return exchange.getIn().getBody(type); 121 } 122 123 @Override 124 public String toString() { 125 return "bodyAs[" + type.getName() + "]"; 126 } 127 }; 128 } 129 130 /** 131 * Returns the expression for the out messages body 132 */ 133 public static <E extends Exchange> Expression<E> outBodyExpression() { 134 return new Expression<E>() { 135 public Object evaluate(E exchange) { 136 return exchange.getOut().getBody(); 137 } 138 139 @Override 140 public String toString() { 141 return "outBody"; 142 } 143 }; 144 } 145 146 /** 147 * Returns the expression for the exchange 148 */ 149 public static <E extends Exchange> Expression<E> exchangeExpression() { 150 return new Expression<E>() { 151 public Object evaluate(E exchange) { 152 return exchange; 153 } 154 155 @Override 156 public String toString() { 157 return "exchange"; 158 } 159 }; 160 } 161 162 /** 163 * Returns the expression for the IN message 164 */ 165 public static <E extends Exchange> Expression<E> inMessageExpression() { 166 return new Expression<E>() { 167 public Object evaluate(E exchange) { 168 return exchange.getIn(); 169 } 170 171 @Override 172 public String toString() { 173 return "inMessage"; 174 } 175 }; 176 } 177 178 /** 179 * Returns an expression which converts the given expression to the given type 180 */ 181 public static <E extends Exchange> Expression<E> convertTo(final Expression expression, final Class type) { 182 return new Expression<E>() { 183 public Object evaluate(E exchange) { 184 Object value = expression.evaluate(exchange); 185 return exchange.getContext().getTypeConverter().convertTo(type, value); 186 } 187 188 @Override 189 public String toString() { 190 return "convertTo(" + expression + ", " + type + ")"; 191 } 192 }; 193 } 194 195 /** 196 * Returns a tokenize expression which will tokenize the string with the given token 197 */ 198 public static <E extends Exchange> Expression<E> tokenizeExpression(final Expression<E> expression, final String token) { 199 return new Expression<E>() { 200 public Object evaluate(E exchange) { 201 String text = evaluateStringExpression(expression, exchange); 202 if (text == null) { 203 return null; 204 } 205 StringTokenizer iter = new StringTokenizer(text, token); 206 List<String> answer = new ArrayList<String>(); 207 while (iter.hasMoreTokens()) { 208 answer.add(iter.nextToken()); 209 } 210 return answer; 211 } 212 213 @Override 214 public String toString() { 215 return "tokenize(" + expression + ", " + token + ")"; 216 } 217 }; 218 } 219 220 /** 221 * Returns a tokenize expression which will tokenize the string with the given regex 222 */ 223 public static <E extends Exchange> Expression<E> regexTokenize(final Expression<E> expression, String regexTokenizer) { 224 final Pattern pattern = Pattern.compile(regexTokenizer); 225 return new Expression<E>() { 226 public Object evaluate(E exchange) { 227 String text = evaluateStringExpression(expression, exchange); 228 if (text == null) { 229 return null; 230 } 231 return Arrays.asList(pattern.split(text)); 232 } 233 234 @Override 235 public String toString() { 236 return "regexTokenize(" + expression + ", " + pattern.pattern() + ")"; 237 } 238 }; 239 } 240 241 /** 242 * Transforms the expression into a String then performs the regex replaceAll to transform the String and return the result 243 */ 244 public static <E extends Exchange> Expression<E> regexReplaceAll(final Expression<E> expression, String regex, final String replacement) { 245 final Pattern pattern = Pattern.compile(regex); 246 return new Expression<E>() { 247 public Object evaluate(E exchange) { 248 String text = evaluateStringExpression(expression, exchange); 249 if (text == null) { 250 return null; 251 } 252 return pattern.matcher(text).replaceAll(replacement); 253 } 254 255 @Override 256 public String toString() { 257 return "regexReplaceAll(" + expression + ", " + pattern.pattern() + ")"; 258 } 259 }; 260 } 261 262 /** 263 * Transforms the expression into a String then performs the regex replaceAll to transform the String and return the result 264 */ 265 public static <E extends Exchange> Expression<E> regexReplaceAll(final Expression<E> expression, String regex, final Expression<E> replacementExpression) { 266 final Pattern pattern = Pattern.compile(regex); 267 return new Expression<E>() { 268 public Object evaluate(E exchange) { 269 String text = evaluateStringExpression(expression, exchange); 270 String replacement = evaluateStringExpression(replacementExpression, exchange);; 271 if (text == null || replacement == null) { 272 return null; 273 } 274 return pattern.matcher(text).replaceAll(replacement); 275 } 276 277 @Override 278 public String toString() { 279 return "regexReplaceAll(" + expression + ", " + pattern.pattern() + ")"; 280 } 281 }; 282 } 283 284 285 /** 286 * Appends the String evaluations of the two expressions together 287 */ 288 public static <E extends Exchange> Expression<E> append(final Expression<E> left, final Expression<E> right) { 289 return new Expression<E>() { 290 public Object evaluate(E exchange) { 291 return evaluateStringExpression(left, exchange) + evaluateStringExpression(right, exchange); 292 } 293 294 @Override 295 public String toString() { 296 return "append(" + left + ", " + right + ")"; 297 } 298 }; 299 } 300 301 /** 302 * Evaluates the expression on the given exchange and returns the String representation 303 * 304 * @param expression the expression to evaluate 305 * @param exchange the exchange to use to evaluate the expression 306 * @return the String representation of the expression or null if it could not be evaluated 307 */ 308 public static <E extends Exchange> String evaluateStringExpression(Expression<E> expression, E exchange) { 309 Object value = expression.evaluate(exchange); 310 return exchange.getContext().getTypeConverter().convertTo(String.class, value); 311 } 312 313 /** 314 * Returns an expression for the given system property 315 */ 316 public static <E extends Exchange> Expression<E> systemProperty(final String name) { 317 return systemProperty(name, null); 318 } 319 320 /** 321 * Returns an expression for the given system property 322 */ 323 public static <E extends Exchange> Expression<E> systemProperty(final String name, final String defaultValue) { 324 return new Expression<E>() { 325 public Object evaluate(E exchange) { 326 return System.getProperty(name, defaultValue); 327 } 328 }; 329 } 330 }