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