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: 52589 $
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 public Predicate<E> matchesRegex(String regex) {
086 return onNewPredicate(PredicateBuilder.regex(expression, regex));
087 }
088
089 public Predicate<E> isNull() {
090 return onNewPredicate(PredicateBuilder.isNull(expression));
091 }
092
093 public Predicate<E> isNotNull() {
094 return onNewPredicate(PredicateBuilder.isNotNull(expression));
095 }
096
097 /**
098 * Create a predicate that the left hand expression contains the value of
099 * the right hand expression
100 *
101 * @param value the element which is compared to be contained within this
102 * expression
103 * @return a predicate which evaluates to true if the given value expression
104 * is contained within this expression value
105 */
106 public Predicate<E> contains(Object value) {
107 Expression<E> right = asExpression(value);
108 return onNewPredicate(PredicateBuilder.contains(expression, right));
109 }
110
111 /**
112 * Creates a predicate which is true if this expression matches the given
113 * regular expression
114 *
115 * @param regex the regular expression to match
116 * @return a predicate which evaluates to true if the expression matches the
117 * regex
118 */
119 public Predicate<E> regex(String regex) {
120 return onNewPredicate(PredicateBuilder.regex(expression, regex));
121 }
122
123 // Expression builders
124 // -------------------------------------------------------------------------
125
126 public ValueBuilder<E> tokenize() {
127 return tokenize("\n");
128 }
129
130 public ValueBuilder<E> tokenize(String token) {
131 Expression<E> newExp = ExpressionBuilder.tokenizeExpression(expression, token);
132 return new ValueBuilder<E>(newExp);
133 }
134
135 /**
136 * Tokenizes the string conversion of this expression using the given
137 * regular expression
138 */
139 public ValueBuilder<E> regexTokenize(String regex) {
140 Expression<E> newExp = ExpressionBuilder.regexTokenize(expression, regex);
141 return new ValueBuilder<E>(newExp);
142 }
143
144 /**
145 * Replaces all occurrencies of the regular expression with the given
146 * replacement
147 */
148 public ValueBuilder<E> regexReplaceAll(String regex, String replacement) {
149 Expression<E> newExp = ExpressionBuilder.regexReplaceAll(expression, regex, replacement);
150 return new ValueBuilder<E>(newExp);
151 }
152
153 /**
154 * Replaces all occurrencies of the regular expression with the given
155 * replacement
156 */
157 public ValueBuilder<E> regexReplaceAll(String regex, Expression<E> replacement) {
158 Expression<E> newExp = ExpressionBuilder.regexReplaceAll(expression, regex, replacement);
159 return new ValueBuilder<E>(newExp);
160 }
161
162 /**
163 * Converts the current value to the given type using the registered type
164 * converters
165 *
166 * @param type the type to convert the value to
167 * @return the current builder
168 */
169 public ValueBuilder<E> convertTo(Class type) {
170 Expression<E> newExp = ExpressionBuilder.convertTo(expression, type);
171 return new ValueBuilder<E>(newExp);
172 }
173
174 /**
175 * Converts the current value a String using the registered type converters
176 *
177 * @return the current builder
178 */
179 public ValueBuilder<E> convertToString() {
180 return convertTo(String.class);
181 }
182
183 /**
184 * Appends the string evaluation of this expression with the given value
185 *
186 * @param value the value or expression to append
187 * @return the current builder
188 */
189 public ValueBuilder<E> append(Object value) {
190 return new ValueBuilder<E>(ExpressionBuilder.append(expression, asExpression(value)));
191 }
192
193 // Implementation methods
194 // -------------------------------------------------------------------------
195
196 /**
197 * A stategy method to allow derived classes to deal with the newly created
198 * predicate in different ways
199 */
200 protected Predicate<E> onNewPredicate(Predicate<E> predicate) {
201 return predicate;
202 }
203
204 protected Expression<E> asExpression(Object value) {
205 if (value instanceof Expression) {
206 return (Expression<E>)value;
207 } else {
208 return ExpressionBuilder.constantExpression(value);
209 }
210 }
211 }