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    }