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 org.apache.camel.Exchange;
020 import org.apache.camel.Expression;
021 import org.apache.camel.Predicate;
022
023 /**
024 * A builder of expressions or predicates based on values.
025 *
026 * @version $Revision: 745602 $
027 */
028 public class ValueBuilder<E extends Exchange> implements Expression<E> {
029 private Expression<E> expression;
030
031 public ValueBuilder(Expression<E> expression) {
032 this.expression = expression;
033 }
034
035 public Object evaluate(E exchange) {
036 return expression.evaluate(exchange);
037 }
038
039 public Expression<E> getExpression() {
040 return expression;
041 }
042
043 @Override
044 public String toString() {
045 return expression.toString();
046 }
047
048 // Predicate builders
049 // -------------------------------------------------------------------------
050
051 public Predicate<E> isNotEqualTo(Object value) {
052 Expression<E> right = asExpression(value);
053 return onNewPredicate(PredicateBuilder.isNotEqualTo(expression, right));
054 }
055
056 public Predicate<E> isEqualTo(Object value) {
057 Expression<E> right = asExpression(value);
058 return onNewPredicate(PredicateBuilder.isEqualTo(expression, right));
059 }
060
061 public Predicate<E> isLessThan(Object value) {
062 Expression<E> right = asExpression(value);
063 return onNewPredicate(PredicateBuilder.isLessThan(expression, right));
064 }
065
066 public Predicate<E> isLessThanOrEqualTo(Object value) {
067 Expression<E> right = asExpression(value);
068 return onNewPredicate(PredicateBuilder.isLessThanOrEqualTo(expression, right));
069 }
070
071 public Predicate<E> isGreaterThan(Object value) {
072 Expression<E> right = asExpression(value);
073 return onNewPredicate(PredicateBuilder.isGreaterThan(expression, right));
074 }
075
076 public Predicate<E> isGreaterThanOrEqualTo(Object value) {
077 Expression<E> right = asExpression(value);
078 return onNewPredicate(PredicateBuilder.isGreaterThanOrEqualTo(expression, right));
079 }
080
081 public Predicate<E> isInstanceOf(Class type) {
082 return onNewPredicate(PredicateBuilder.isInstanceOf(expression, type));
083 }
084
085 /**
086 * @deprecated use {@link #regex(String)}. Will be removed in Camel 2.0
087 */
088 public Predicate<E> matchesRegex(String regex) {
089 return onNewPredicate(PredicateBuilder.regex(expression, regex));
090 }
091
092 public Predicate<E> isNull() {
093 return onNewPredicate(PredicateBuilder.isNull(expression));
094 }
095
096 public Predicate<E> isNotNull() {
097 return onNewPredicate(PredicateBuilder.isNotNull(expression));
098 }
099
100 /**
101 * Create a predicate that the left hand expression contains the value of
102 * the right hand expression
103 *
104 * @param value the element which is compared to be contained within this
105 * expression
106 * @return a predicate which evaluates to true if the given value expression
107 * is contained within this expression value
108 */
109 public Predicate<E> contains(Object value) {
110 Expression<E> right = asExpression(value);
111 return onNewPredicate(PredicateBuilder.contains(expression, right));
112 }
113
114 /**
115 * Creates a predicate which is true if this expression matches the given
116 * regular expression
117 *
118 * @param regex the regular expression to match
119 * @return a predicate which evaluates to true if the expression matches the
120 * regex
121 */
122 public Predicate<E> regex(String regex) {
123 return onNewPredicate(PredicateBuilder.regex(expression, regex));
124 }
125
126 // Expression builders
127 // -------------------------------------------------------------------------
128
129 public ValueBuilder<E> tokenize() {
130 return tokenize("\n");
131 }
132
133 public ValueBuilder<E> tokenize(String token) {
134 Expression<E> newExp = ExpressionBuilder.tokenizeExpression(expression, token);
135 return new ValueBuilder<E>(newExp);
136 }
137
138 /**
139 * Tokenizes the string conversion of this expression using the given
140 * regular expression
141 */
142 public ValueBuilder<E> regexTokenize(String regex) {
143 Expression<E> newExp = ExpressionBuilder.regexTokenize(expression, regex);
144 return new ValueBuilder<E>(newExp);
145 }
146
147 /**
148 * Replaces all occurrences of the regular expression with the given
149 * replacement
150 */
151 public ValueBuilder<E> regexReplaceAll(String regex, String replacement) {
152 Expression<E> newExp = ExpressionBuilder.regexReplaceAll(expression, regex, replacement);
153 return new ValueBuilder<E>(newExp);
154 }
155
156 /**
157 * Replaces all occurrences of the regular expression with the given
158 * replacement
159 */
160 public ValueBuilder<E> regexReplaceAll(String regex, Expression<E> replacement) {
161 Expression<E> newExp = ExpressionBuilder.regexReplaceAll(expression, regex, replacement);
162 return new ValueBuilder<E>(newExp);
163 }
164
165 /**
166 * Converts the current value to the given type using the registered type
167 * converters
168 *
169 * @param type the type to convert the value to
170 * @return the current builder
171 */
172 public ValueBuilder<E> convertTo(Class type) {
173 Expression<E> newExp = ExpressionBuilder.convertTo(expression, type);
174 return new ValueBuilder<E>(newExp);
175 }
176
177 /**
178 * Converts the current value a String using the registered type converters
179 *
180 * @return the current builder
181 */
182 public ValueBuilder<E> convertToString() {
183 return convertTo(String.class);
184 }
185
186 /**
187 * Appends the string evaluation of this expression with the given value
188 *
189 * @param value the value or expression to append
190 * @return the current builder
191 */
192 public ValueBuilder<E> append(Object value) {
193 return new ValueBuilder<E>(ExpressionBuilder.append(expression, asExpression(value)));
194 }
195
196 // Implementation methods
197 // -------------------------------------------------------------------------
198
199 /**
200 * A strategy method to allow derived classes to deal with the newly created
201 * predicate in different ways
202 */
203 protected Predicate<E> onNewPredicate(Predicate<E> predicate) {
204 return predicate;
205 }
206
207 protected Expression<E> asExpression(Object value) {
208 if (value instanceof Expression) {
209 return (Expression<E>)value;
210 } else {
211 return ExpressionBuilder.constantExpression(value);
212 }
213 }
214 }