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