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