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.Arrays;
021    import java.util.List;
022    
023    import org.apache.camel.CamelContext;
024    import org.apache.camel.Endpoint;
025    import org.apache.camel.Expression;
026    import org.apache.camel.LoggingLevel;
027    import org.apache.camel.NoSuchEndpointException;
028    import org.apache.camel.util.ObjectHelper;
029    import org.apache.commons.logging.Log;
030    import org.apache.commons.logging.LogFactory;
031    
032    /**
033     * Base class for implementation inheritance for different clauses in the <a
034     * href="http://camel.apache.org/dsl.html">Java DSL</a>
035     *
036     * @version $Revision: 784652 $
037     */
038    public abstract class BuilderSupport {
039        private CamelContext context;
040        private ErrorHandlerBuilder errorHandlerBuilder;
041    
042        protected BuilderSupport(CamelContext context) {
043            this.context = context;
044        }
045    
046        // Builder methods
047        // -------------------------------------------------------------------------
048    
049        /**
050         * Returns a value builder for the given header
051         */
052        public ValueBuilder header(String name) {
053            return Builder.header(name);
054        }
055    
056        /**
057         * Returns a value builder for the given property
058         */
059        public ValueBuilder property(String name) {
060            return Builder.property(name);
061        }   
062        
063        /**
064         * Returns a predicate and value builder for the inbound body on an exchange
065         */
066        public ValueBuilder body() {
067            return Builder.body();
068        }
069    
070        /**
071         * Returns a predicate and value builder for the inbound message body as a
072         * specific type
073         */
074        public <T> ValueBuilder body(Class<T> type) {
075            return Builder.bodyAs(type);
076        }
077    
078        /**
079         * Returns a predicate and value builder for the outbound body on an
080         * exchange
081         */
082        public ValueBuilder outBody() {
083            return Builder.outBody();
084        }
085    
086        /**
087         * Returns a predicate and value builder for the outbound message body as a
088         * specific type
089         */
090        public <T> ValueBuilder outBody(Class<T> type) {
091            return Builder.outBodyAs(type);
092        }
093    
094        /**
095         * Returns a predicate and value builder for the fault body on an
096         * exchange
097         */
098        public ValueBuilder faultBody() {
099            return Builder.faultBody();
100        }
101    
102        /**
103         * Returns a predicate and value builder for the fault message body as a
104         * specific type
105         */
106        public <T> ValueBuilder faultBodyAs(Class<T> type) {
107            return Builder.faultBodyAs(type);
108        }
109                                 
110        /**
111         * Returns a value builder for the given system property
112         */
113        public ValueBuilder systemProperty(String name) {
114            return Builder.systemProperty(name);
115        }
116    
117        /**
118         * Returns a value builder for the given system property
119         */
120        public ValueBuilder systemProperty(String name, String defaultValue) {
121            return Builder.systemProperty(name, defaultValue);
122        }
123    
124        /**
125         * Returns a constant expression value builder
126         */
127        public ValueBuilder constant(Object value) {
128            return Builder.constant(value);
129        }
130    
131        /**
132         * Returns a <a href="http://camel.apache.org/bean-language.html">bean expression</a>
133         * value builder
134         *
135         * @param beanRef  reference to bean to lookup in the Registry
136         * @return the builder
137         */
138        public ValueBuilder bean(String beanRef) {
139            return Builder.bean(beanRef, null);
140        }
141        
142        /**
143         * Returns a <a href="http://camel.apache.org/bean-language.html">bean expression</a>
144         * value builder
145         *
146         * @param beanRef  reference to bean to lookup in the Registry
147         * @param method   name of method to invoke
148         * @return the builder
149         */
150        public ValueBuilder bean(String beanRef, String method) {
151            return Builder.bean(beanRef, method);
152        }
153    
154        /**
155         * Returns a <a href="http://camel.apache.org/bean-language.html">bean expression</a>
156         * value builder
157         *
158         * @param beanType the Class of the bean which we want to invoke
159         * @return the builder
160         */
161        public ValueBuilder bean(Class beanType) {
162            return Builder.bean(beanType, null);
163        }
164        
165        /**
166         * Returns a <a href="http://camel.apache.org/bean-language.html">bean expression</a>
167         * value builder
168         *
169         * @param beanType the Class of the bean which we want to invoke
170         * @param method   name of method to invoke
171         * @return the builder
172         */
173        public ValueBuilder bean(Class beanType, String method) {
174            return Builder.bean(beanType, method);
175        }
176    
177        /**
178         * Returns an expression processing the exchange to the given endpoint uri
179         *
180         * @param uri endpoint uri to send the exchange to
181         * @return the builder
182         */
183        public ValueBuilder sendTo(String uri) {
184            return Builder.sendTo(uri);
185        }
186    
187        /**
188         * Returns an expression value builder that replaces all occurrences of the 
189         * regular expression with the given replacement
190         */
191        public ValueBuilder regexReplaceAll(Expression content, String regex, String replacement) {
192            return Builder.regexReplaceAll(content, regex, replacement);
193        }
194    
195        /**
196         * Returns an expression value builder that replaces all occurrences of the 
197         * regular expression with the given replacement
198         */
199        public ValueBuilder regexReplaceAll(Expression content, String regex, Expression replacement) {
200            return Builder.regexReplaceAll(content, regex, replacement);
201        }    
202        
203        /**
204         * Returns a exception expression value builder
205         */
206        public ValueBuilder exceptionMessage() {
207            return Builder.exceptionMessage();
208        }
209    
210        /**
211         * Resolves the given URI to an endpoint
212         *
213         * @param uri  the uri to resolve
214         * @throws NoSuchEndpointException if the endpoint URI could not be resolved
215         * @return the endpoint
216         */
217        public Endpoint endpoint(String uri) throws NoSuchEndpointException {
218            ObjectHelper.notNull(uri, "uri");
219            Endpoint endpoint = getContext().getEndpoint(uri);
220            if (endpoint == null) {
221                throw new NoSuchEndpointException(uri);
222            }
223            return endpoint;
224        }
225    
226        /**
227         * Resolves the given URI to an endpoint of the specified type
228         *
229         * @param uri  the uri to resolve
230         * @param type the excepted type of the endpoint
231         * @throws NoSuchEndpointException if the endpoint URI could not be resolved
232         * @return the endpoint
233         */
234        public <T extends Endpoint> T endpoint(String uri, Class<T> type) throws NoSuchEndpointException {
235            ObjectHelper.notNull(uri, "uri");
236            T endpoint = getContext().getEndpoint(uri, type);
237            if (endpoint == null) {
238                throw new NoSuchEndpointException(uri);
239            }
240            return endpoint;
241        }
242    
243        /**
244         * Resolves the list of URIs into a list of {@link Endpoint} instances
245         *
246         * @param uris  list of endpoints to resolve
247         * @throws NoSuchEndpointException if an endpoint URI could not be resolved
248         * @return list of endpoints
249         */
250        public List<Endpoint> endpoints(String... uris) throws NoSuchEndpointException {
251            List<Endpoint> endpoints = new ArrayList<Endpoint>();
252            for (String uri : uris) {
253                endpoints.add(endpoint(uri));
254            }
255            return endpoints;
256        }
257    
258        /**
259         * Helper method to create a list of {@link Endpoint} instances
260         *
261         * @param endpoints  endpoints
262         * @return list of the given endpoints
263         */
264        public List<Endpoint> endpoints(Endpoint... endpoints) {
265            List<Endpoint> answer = new ArrayList<Endpoint>();
266            answer.addAll(Arrays.asList(endpoints));
267            return answer;
268        }
269    
270        /**
271         * Creates a default <a href="http://camel.apache.org/error-handler.html">error handler</a>.
272         *
273         * @return the builder
274         */
275        public DefaultErrorHandlerBuilder defaultErrorHandler() {
276            return new DefaultErrorHandlerBuilder();
277        }
278    
279        /**
280         * Creates a disabled <a href="http://camel.apache.org/error-handler.html">error handler</a>
281         * for removing the default error handler
282         *
283         * @return the builder
284         */
285        public NoErrorHandlerBuilder noErrorHandler() {
286            return new NoErrorHandlerBuilder();
287        }
288    
289        /**
290         * Creates an <a href="http://camel.apache.org/error-handler.html">error handler</a>
291         * which just logs errors
292         *
293         * @return the builder
294         */
295        public LoggingErrorHandlerBuilder loggingErrorHandler() {
296            return new LoggingErrorHandlerBuilder();
297        }
298    
299        /**
300         * Creates an <a href="http://camel.apache.org/error-handler.html">error handler</a>
301         * which just logs errors
302         *
303         * @return the builder
304         */
305        public LoggingErrorHandlerBuilder loggingErrorHandler(String log) {
306            return loggingErrorHandler(LogFactory.getLog(log));
307        }
308    
309        /**
310         * Creates an <a href="http://camel.apache.org/error-handler.html">error handler</a>
311         * which just logs errors
312         *
313         * @return the builder
314         */
315        public LoggingErrorHandlerBuilder loggingErrorHandler(Log log) {
316            return new LoggingErrorHandlerBuilder(log);
317        }
318    
319        /**
320         * Creates an <a href="http://camel.apache.org/error-handler.html">error handler</a>
321         * which just logs errors
322         *
323         * @return the builder
324         */
325        public LoggingErrorHandlerBuilder loggingErrorHandler(Log log, LoggingLevel level) {
326            return new LoggingErrorHandlerBuilder(log, level);
327        }
328    
329        /**
330         * <a href="http://camel.apache.org/dead-letter-channel.html">Dead Letter Channel EIP:</a>
331         * is a error handler for handling messages that could not be delivered to it's intented destination.
332         *
333         * @param deadLetterUri  uri to the dead letter endpoint storing dead messages
334         * @return the builder
335         */
336        public DeadLetterChannelBuilder deadLetterChannel(String deadLetterUri) {
337            return deadLetterChannel(endpoint(deadLetterUri));
338        }
339    
340        /**
341         * <a href="http://camel.apache.org/dead-letter-channel.html">Dead Letter Channel EIP:</a>
342         * is a error handler for handling messages that could not be delivered to it's intented destination.
343         *
344         * @param deadLetterEndpoint  dead letter endpoint storing dead messages
345         * @return the builder
346         */
347        public DeadLetterChannelBuilder deadLetterChannel(Endpoint deadLetterEndpoint) {
348            return new DeadLetterChannelBuilder(deadLetterEndpoint);
349        }
350    
351        // Properties
352        // -------------------------------------------------------------------------
353    
354        public CamelContext getContext() {
355            return context;
356        }
357    
358        public void setContext(CamelContext context) {
359            this.context = context;
360        }
361    
362        public ErrorHandlerBuilder getErrorHandlerBuilder() {
363            if (errorHandlerBuilder == null) {
364                errorHandlerBuilder = createErrorHandlerBuilder();
365            }
366            return errorHandlerBuilder;
367        }
368    
369        protected ErrorHandlerBuilder createErrorHandlerBuilder() {
370            return new DefaultErrorHandlerBuilder();
371        }
372    
373        /**
374         * Sets the error handler to use with processors created by this builder
375         */
376        public void setErrorHandlerBuilder(ErrorHandlerBuilder errorHandlerBuilder) {
377            this.errorHandlerBuilder = errorHandlerBuilder;
378        }
379    
380    }