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