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