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
020 import java.util.regex.Matcher;
021 import java.util.regex.Pattern;
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.ObjectHelper;
027
028 import static org.apache.camel.util.ObjectHelper.compare;
029 import static org.apache.camel.util.ObjectHelper.notNull;
030
031
032 /**
033 * A helper class for working with predicates
034 *
035 * @version $Revision: 688281 $
036 */
037 public final class PredicateBuilder {
038
039 /**
040 * Utility classes should not have a public constructor.
041 */
042 private PredicateBuilder() {
043 }
044
045 /**
046 * Converts the given expression into an {@link Predicate}
047 */
048 public static <E extends Exchange> Predicate<E> toPredicate(final Expression<E> expression) {
049 return new PredicateSupport<E>() {
050 public boolean matches(E exchange) {
051 Object value = expression.evaluate(exchange);
052 return ObjectHelper.evaluateValuePredicate(value);
053 }
054
055 @Override
056 public String toString() {
057 return expression.toString();
058 }
059 };
060 }
061
062 /**
063 * A helper method to return the logical not of the given predicate
064 */
065 public static <E extends Exchange> Predicate<E> not(final Predicate<E> predicate) {
066 notNull(predicate, "predicate");
067 return new PredicateSupport<E>() {
068 public boolean matches(E exchange) {
069 return !predicate.matches(exchange);
070 }
071
072 @Override
073 public String toString() {
074 return "not " + predicate;
075 }
076 };
077 }
078
079 /**
080 * A helper method to combine multiple predicates by a logical AND
081 */
082 public static <E extends Exchange> Predicate<E> and(final Predicate<E> left, final Predicate<E> right) {
083 notNull(left, "left");
084 notNull(right, "right");
085 return new PredicateSupport<E>() {
086 public boolean matches(E exchange) {
087 return left.matches(exchange) && right.matches(exchange);
088 }
089
090 @Override
091 public String toString() {
092 return "(" + left + ") and (" + right + ")";
093 }
094 };
095 }
096
097 /**
098 * A helper method to combine multiple predicates by a logical OR
099 */
100 public static <E extends Exchange> Predicate<E> or(final Predicate<E> left, final Predicate<E> right) {
101 notNull(left, "left");
102 notNull(right, "right");
103 return new PredicateSupport<E>() {
104 public boolean matches(E exchange) {
105 return left.matches(exchange) || right.matches(exchange);
106 }
107
108 @Override
109 public String toString() {
110 return "(" + left + ") or (" + right + ")";
111 }
112 };
113 }
114
115 public static <E extends Exchange> Predicate<E> isEqualTo(final Expression<E> left,
116 final Expression<E> right) {
117 return new BinaryPredicateSupport<E>(left, right) {
118
119 protected boolean matches(E exchange, Object leftValue, Object rightValue) {
120 return ObjectHelper.equal(leftValue, rightValue);
121 }
122
123 protected String getOperationText() {
124 return "==";
125 }
126 };
127 }
128
129 public static <E extends Exchange> Predicate<E> isNotEqualTo(final Expression<E> left,
130 final Expression<E> right) {
131 return new BinaryPredicateSupport<E>(left, right) {
132
133 protected boolean matches(E exchange, Object leftValue, Object rightValue) {
134 return !ObjectHelper.equal(leftValue, rightValue);
135 }
136
137 protected String getOperationText() {
138 return "!=";
139 }
140 };
141 }
142
143 public static <E extends Exchange> Predicate<E> isLessThan(final Expression<E> left,
144 final Expression<E> right) {
145 return new BinaryPredicateSupport<E>(left, right) {
146
147 protected boolean matches(E exchange, Object leftValue, Object rightValue) {
148 return compare(leftValue, rightValue) < 0;
149 }
150
151 protected String getOperationText() {
152 return "<";
153 }
154 };
155 }
156
157 public static <E extends Exchange> Predicate<E> isLessThanOrEqualTo(final Expression<E> left,
158 final Expression<E> right) {
159 return new BinaryPredicateSupport<E>(left, right) {
160
161 protected boolean matches(E exchange, Object leftValue, Object rightValue) {
162 return compare(leftValue, rightValue) <= 0;
163 }
164
165 protected String getOperationText() {
166 return "<=";
167 }
168 };
169 }
170
171 public static <E extends Exchange> Predicate<E> isGreaterThan(final Expression<E> left,
172 final Expression<E> right) {
173 return new BinaryPredicateSupport<E>(left, right) {
174
175 protected boolean matches(E exchange, Object leftValue, Object rightValue) {
176 return compare(leftValue, rightValue) > 0;
177 }
178
179 protected String getOperationText() {
180 return ">";
181 }
182 };
183 }
184
185 public static <E extends Exchange> Predicate<E> isGreaterThanOrEqualTo(final Expression<E> left,
186 final Expression<E> right) {
187 return new BinaryPredicateSupport<E>(left, right) {
188
189 protected boolean matches(E exchange, Object leftValue, Object rightValue) {
190 return compare(leftValue, rightValue) >= 0;
191 }
192
193 protected String getOperationText() {
194 return ">=";
195 }
196 };
197 }
198
199 public static <E extends Exchange> Predicate<E> contains(final Expression<E> left,
200 final Expression<E> right) {
201 return new BinaryPredicateSupport<E>(left, right) {
202
203 protected boolean matches(E exchange, Object leftValue, Object rightValue) {
204 return ObjectHelper.contains(leftValue, rightValue);
205 }
206
207 protected String getOperationText() {
208 return "contains";
209 }
210 };
211 }
212
213 public static <E extends Exchange> Predicate<E> isNull(final Expression<E> expression) {
214 return isEqualTo(expression, ExpressionBuilder.<E> constantExpression(null));
215 }
216
217 public static <E extends Exchange> Predicate<E> isNotNull(final Expression<E> expression) {
218 return isNotEqualTo(expression, ExpressionBuilder.<E> constantExpression(null));
219 }
220
221 public static <E extends Exchange> Predicate<E> isInstanceOf(final Expression<E> expression,
222 final Class type) {
223 notNull(expression, "expression");
224 notNull(type, "type");
225
226 return new PredicateSupport<E>() {
227 public boolean matches(E exchange) {
228 Object value = expression.evaluate(exchange);
229 return type.isInstance(value);
230 }
231
232 @Override
233 public String toString() {
234 return expression + " instanceof " + type.getName();
235 }
236
237 @Override
238 protected String assertionFailureMessage(E exchange) {
239 return super.assertionFailureMessage(exchange)
240 + " for <" + expression.evaluate(exchange) + ">";
241 }
242 };
243 }
244
245 /**
246 * Returns a predicate which is true if the expression matches the given
247 * regular expression
248 *
249 * @param expression the expression to evaluate
250 * @param regex the regular expression to match against
251 * @return a new predicate
252 */
253 public static <E extends Exchange> Predicate<E> regex(final Expression<E> expression, final String regex) {
254 return regex(expression, Pattern.compile(regex));
255 }
256
257 /**
258 * Returns a predicate which is true if the expression matches the given
259 * regular expression
260 *
261 * @param expression the expression to evaluate
262 * @param pattern the regular expression to match against
263 * @return a new predicate
264 */
265 public static <E extends Exchange> Predicate<E> regex(final Expression<E> expression,
266 final Pattern pattern) {
267 notNull(expression, "expression");
268 notNull(pattern, "pattern");
269
270 return new PredicateSupport<E>() {
271 public boolean matches(E exchange) {
272 Object value = expression.evaluate(exchange);
273 if (value != null) {
274 Matcher matcher = pattern.matcher(value.toString());
275 return matcher.matches();
276 }
277 return false;
278 }
279
280 @Override
281 public String toString() {
282 return expression + ".matches(" + pattern + ")";
283 }
284
285 @Override
286 protected String assertionFailureMessage(E exchange) {
287 return super.assertionFailureMessage(exchange) + " for <" + expression.evaluate(exchange)
288 + ">";
289 }
290
291 };
292 }
293 }