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: 780937 $
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 /**
117 * Create a predicate that the left hand expression contains the value of
118 * the right hand expression
119 *
120 * @param value the element which is compared to be contained within this
121 * expression
122 * @return a predicate which evaluates to true if the given value expression
123 * is contained within this expression value
124 */
125 public Predicate contains(Object value) {
126 Expression right = asExpression(value);
127 return onNewPredicate(PredicateBuilder.contains(expression, right));
128 }
129
130 /**
131 * Creates a predicate which is true if this expression matches the given
132 * regular expression
133 *
134 * @param regex the regular expression to match
135 * @return a predicate which evaluates to true if the expression matches the
136 * regex
137 */
138 public Predicate regex(String regex) {
139 return onNewPredicate(PredicateBuilder.regex(expression, regex));
140 }
141
142 // Expression builders
143 // -------------------------------------------------------------------------
144
145 public ValueBuilder tokenize() {
146 return tokenize("\n");
147 }
148
149 public ValueBuilder tokenize(String token) {
150 Expression newExp = ExpressionBuilder.tokenizeExpression(expression, token);
151 return new ValueBuilder(newExp);
152 }
153
154 /**
155 * Tokenizes the string conversion of this expression using the given
156 * regular expression
157 */
158 public ValueBuilder regexTokenize(String regex) {
159 Expression newExp = ExpressionBuilder.regexTokenizeExpression(expression, regex);
160 return new ValueBuilder(newExp);
161 }
162
163 /**
164 * Replaces all occurrences of the regular expression with the given
165 * replacement
166 */
167 public ValueBuilder regexReplaceAll(String regex, String replacement) {
168 Expression newExp = ExpressionBuilder.regexReplaceAll(expression, regex, replacement);
169 return new ValueBuilder(newExp);
170 }
171
172 /**
173 * Replaces all occurrences of the regular expression with the given
174 * replacement
175 */
176 public ValueBuilder regexReplaceAll(String regex, Expression replacement) {
177 Expression newExp = ExpressionBuilder.regexReplaceAll(expression, regex, replacement);
178 return new ValueBuilder(newExp);
179 }
180
181 /**
182 * Converts the current value to the given type using the registered type
183 * converters
184 *
185 * @param type the type to convert the value to
186 * @return the current builder
187 */
188 public ValueBuilder convertTo(Class<?> type) {
189 Expression newExp = ExpressionBuilder.convertToExpression(expression, type);
190 return new ValueBuilder(newExp);
191 }
192
193 /**
194 * Converts the current value to a String using the registered type converters
195 *
196 * @return the current builder
197 */
198 public ValueBuilder convertToString() {
199 return convertTo(String.class);
200 }
201
202 /**
203 * Appends the string evaluation of this expression with the given value
204 *
205 * @param value the value or expression to append
206 * @return the current builder
207 */
208 public ValueBuilder append(Object value) {
209 return new ValueBuilder(ExpressionBuilder.append(expression, asExpression(value)));
210 }
211
212 /**
213 * Prepends the string evaluation of this expression with the given value
214 *
215 * @param value the value or expression to prepend
216 * @return the current builder
217 */
218 public ValueBuilder prepend(Object value) {
219 return new ValueBuilder(ExpressionBuilder.prepend(expression, asExpression(value)));
220 }
221
222 /**
223 * Sorts the current value using the given comparator. The current value must be convertable
224 * to a {@link List} to allow sorting using the comparator.
225 *
226 * @param comparator the comparator used by sorting
227 * @return the current builder
228 */
229 public ValueBuilder sort(Comparator comparator) {
230 Expression newExp = ExpressionBuilder.sortExpression(expression, comparator);
231 return new ValueBuilder(newExp);
232 }
233
234 // Implementation methods
235 // -------------------------------------------------------------------------
236
237 /**
238 * A strategy method to allow derived classes to deal with the newly created
239 * predicate in different ways
240 */
241 protected Predicate onNewPredicate(Predicate predicate) {
242 return predicate;
243 }
244
245 protected Expression asExpression(Object value) {
246 if (value instanceof Expression) {
247 return (Expression)value;
248 } else {
249 return ExpressionBuilder.constantExpression(value);
250 }
251 }
252 }