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