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.Comparator;
021 import java.util.List;
022
023 import org.apache.camel.Exchange;
024 import org.apache.camel.Expression;
025 import org.apache.camel.Predicate;
026
027 /**
028 * A builder of expressions or predicates based on values.
029 *
030 * @version $Revision: 746225 $
031 */
032 public class ValueBuilder implements Expression {
033 private Expression expression;
034
035 public ValueBuilder(Expression expression) {
036 this.expression = expression;
037 }
038
039 public Object evaluate(Exchange exchange) {
040 return expression.evaluate(exchange);
041 }
042
043 public <T> T evaluate(Exchange exchange, Class<T> type) {
044 Object result = evaluate(exchange);
045 return exchange.getContext().getTypeConverter().convertTo(type, result);
046 }
047
048 public Expression getExpression() {
049 return expression;
050 }
051
052 @Override
053 public String toString() {
054 return expression.toString();
055 }
056
057 // Predicate builders
058 // -------------------------------------------------------------------------
059
060 public Predicate isNotEqualTo(Object value) {
061 Expression right = asExpression(value);
062 return onNewPredicate(PredicateBuilder.isNotEqualTo(expression, right));
063 }
064
065 public Predicate isEqualTo(Object value) {
066 Expression right = asExpression(value);
067 return onNewPredicate(PredicateBuilder.isEqualTo(expression, right));
068 }
069
070 public Predicate isLessThan(Object value) {
071 Expression right = asExpression(value);
072 return onNewPredicate(PredicateBuilder.isLessThan(expression, right));
073 }
074
075 public Predicate isLessThanOrEqualTo(Object value) {
076 Expression right = asExpression(value);
077 return onNewPredicate(PredicateBuilder.isLessThanOrEqualTo(expression, right));
078 }
079
080 public Predicate isGreaterThan(Object value) {
081 Expression right = asExpression(value);
082 return onNewPredicate(PredicateBuilder.isGreaterThan(expression, right));
083 }
084
085 public Predicate isGreaterThanOrEqualTo(Object value) {
086 Expression right = asExpression(value);
087 return onNewPredicate(PredicateBuilder.isGreaterThanOrEqualTo(expression, right));
088 }
089
090 public Predicate isInstanceOf(Class type) {
091 return onNewPredicate(PredicateBuilder.isInstanceOf(expression, type));
092 }
093
094 public Predicate isNull() {
095 return onNewPredicate(PredicateBuilder.isNull(expression));
096 }
097
098 public Predicate isNotNull() {
099 return onNewPredicate(PredicateBuilder.isNotNull(expression));
100 }
101
102 public Predicate not(Predicate predicate) {
103 return onNewPredicate(PredicateBuilder.not(predicate));
104 }
105
106 public Predicate in(Object... values) {
107 List<Predicate> predicates = new ArrayList<Predicate>();
108 for (Object value : values) {
109 Expression right = asExpression(value);
110 right = ExpressionBuilder.convertToExpression(right, expression);
111 Predicate predicate = onNewPredicate(PredicateBuilder.isEqualTo(expression, right));
112 predicates.add(predicate);
113 }
114 return in(predicates.toArray(new Predicate[predicates.size()]));
115 }
116
117 public Predicate in(Predicate... predicates) {
118 return onNewPredicate(PredicateBuilder.in(predicates));
119 }
120
121 /**
122 * Create a predicate that the left hand expression contains the value of
123 * the right hand expression
124 *
125 * @param value the element which is compared to be contained within this
126 * expression
127 * @return a predicate which evaluates to true if the given value expression
128 * is contained within this expression value
129 */
130 public Predicate contains(Object value) {
131 Expression right = asExpression(value);
132 return onNewPredicate(PredicateBuilder.contains(expression, right));
133 }
134
135 /**
136 * Creates a predicate which is true if this expression matches the given
137 * regular expression
138 *
139 * @param regex the regular expression to match
140 * @return a predicate which evaluates to true if the expression matches the
141 * regex
142 */
143 public Predicate regex(String regex) {
144 return onNewPredicate(PredicateBuilder.regex(expression, regex));
145 }
146
147 // Expression builders
148 // -------------------------------------------------------------------------
149
150 public ValueBuilder tokenize() {
151 return tokenize("\n");
152 }
153
154 public ValueBuilder tokenize(String token) {
155 Expression newExp = ExpressionBuilder.tokenizeExpression(expression, token);
156 return new ValueBuilder(newExp);
157 }
158
159 /**
160 * Tokenizes the string conversion of this expression using the given
161 * regular expression
162 */
163 public ValueBuilder regexTokenize(String regex) {
164 Expression newExp = ExpressionBuilder.regexTokenizeExpression(expression, regex);
165 return new ValueBuilder(newExp);
166 }
167
168 /**
169 * Replaces all occurrences of the regular expression with the given
170 * replacement
171 */
172 public ValueBuilder regexReplaceAll(String regex, String replacement) {
173 Expression newExp = ExpressionBuilder.regexReplaceAll(expression, regex, replacement);
174 return new ValueBuilder(newExp);
175 }
176
177 /**
178 * Replaces all occurrences of the regular expression with the given
179 * replacement
180 */
181 public ValueBuilder regexReplaceAll(String regex, Expression replacement) {
182 Expression newExp = ExpressionBuilder.regexReplaceAll(expression, regex, replacement);
183 return new ValueBuilder(newExp);
184 }
185
186 /**
187 * Converts the current value to the given type using the registered type
188 * converters
189 *
190 * @param type the type to convert the value to
191 * @return the current builder
192 */
193 public ValueBuilder convertTo(Class<?> type) {
194 Expression newExp = ExpressionBuilder.convertToExpression(expression, type);
195 return new ValueBuilder(newExp);
196 }
197
198 /**
199 * Converts the current value to a String using the registered type converters
200 *
201 * @return the current builder
202 */
203 public ValueBuilder convertToString() {
204 return convertTo(String.class);
205 }
206
207 /**
208 * Appends the string evaluation of this expression with the given value
209 *
210 * @param value the value or expression to append
211 * @return the current builder
212 */
213 public ValueBuilder append(Object value) {
214 return new ValueBuilder(ExpressionBuilder.append(expression, asExpression(value)));
215 }
216
217 /**
218 * Sorts the current value using the given comparator. The current value must be convertable
219 * to a {@link List} to allow sorting using the comparator.
220 *
221 * @param comparator the comparator used by sorting
222 * @return the current builder
223 */
224 public ValueBuilder sort(Comparator comparator) {
225 Expression newExp = ExpressionBuilder.sortExpression(expression, comparator);
226 return new ValueBuilder(newExp);
227 }
228
229 // Implementation methods
230 // -------------------------------------------------------------------------
231
232 /**
233 * A strategy method to allow derived classes to deal with the newly created
234 * predicate in different ways
235 */
236 protected Predicate onNewPredicate(Predicate predicate) {
237 return predicate;
238 }
239
240 protected Expression asExpression(Object value) {
241 if (value instanceof Expression) {
242 return (Expression)value;
243 } else {
244 return ExpressionBuilder.constantExpression(value);
245 }
246 }
247 }