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.List;
021    
022    import org.apache.camel.CamelContext;
023    import org.apache.camel.Endpoint;
024    import org.apache.camel.NoSuchEndpointException;
025    import org.apache.camel.processor.LoggingLevel;
026    import org.apache.camel.processor.SendProcessor;
027    import org.apache.commons.logging.Log;
028    import org.apache.commons.logging.LogFactory;
029    
030    /**
031     * Base class for implementation inheritance for different clauses in the <a
032     * href="http://activemq.apache.org/camel/dsl.html">Java DSL</a>
033     * 
034     * @version $Revision: $
035     */
036    public abstract class BuilderSupport {
037        private CamelContext context;
038        private ErrorHandlerBuilder errorHandlerBuilder;
039        private boolean inheritErrorHandler = true;
040    
041        protected BuilderSupport(CamelContext context) {
042            this.context = context;
043        }
044    
045        protected BuilderSupport(BuilderSupport parent) {
046            this.context = parent.getContext();
047            this.inheritErrorHandler = parent.inheritErrorHandler;
048            if (inheritErrorHandler && parent.errorHandlerBuilder != null) {
049                this.errorHandlerBuilder = parent.errorHandlerBuilder.copy();
050            }
051        }
052    
053        // Builder methods
054        // -------------------------------------------------------------------------
055    
056        /**
057         * Returns a value builder for the given header
058         */
059        public ValueBuilder header(String name) {
060            return Builder.header(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 bodyAs(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.outBody(type);
092        }
093    
094        /**
095         * Returns a value builder for the given system property
096         */
097        public ValueBuilder systemProperty(String name) {
098            return Builder.systemProperty(name);
099        }
100    
101        /**
102         * Returns a value builder for the given system property
103         */
104        public ValueBuilder systemProperty(String name, String defaultValue) {
105            return Builder.systemProperty(name, defaultValue);
106        }
107    
108        /**
109         * Resolves the given URI to an endpoint
110         * 
111         * @throws NoSuchEndpointException if the endpoint URI could not be resolved
112         */
113        public Endpoint endpoint(String uri) throws NoSuchEndpointException {
114            if (uri == null) {
115                throw new IllegalArgumentException("uri parameter cannot be null");
116            }
117            Endpoint endpoint = getContext().getEndpoint(uri);
118            if (endpoint == null) {
119                throw new NoSuchEndpointException(uri);
120            }
121            return endpoint;
122        }
123    
124        /**
125         * Resolves the list of URIs into a list of {@link Endpoint} instances
126         * 
127         * @throws NoSuchEndpointException if an endpoint URI could not be resolved
128         */
129        public List<Endpoint> endpoints(String... uris) throws NoSuchEndpointException {
130            List<Endpoint> endpoints = new ArrayList<Endpoint>();
131            for (String uri : uris) {
132                endpoints.add(endpoint(uri));
133            }
134            return endpoints;
135        }
136    
137        /**
138         * Helper method to create a list of {@link Endpoint} instances
139         */
140        public List<Endpoint> endpoints(Endpoint... endpoints) {
141            List<Endpoint> answer = new ArrayList<Endpoint>();
142            for (Endpoint endpoint : endpoints) {
143                answer.add(endpoint);
144            }
145            return answer;
146        }
147    
148        /**
149         * Creates a disabled error handler for removing the default error handler
150         */
151        public NoErrorHandlerBuilder noErrorHandler() {
152            return new NoErrorHandlerBuilder();
153        }
154    
155        /**
156         * Creates an error handler which just logs errors
157         */
158        public LoggingErrorHandlerBuilder loggingErrorHandler() {
159            return new LoggingErrorHandlerBuilder();
160        }
161    
162        /**
163         * Creates an error handler which just logs errors
164         */
165        public LoggingErrorHandlerBuilder loggingErrorHandler(String log) {
166            return loggingErrorHandler(LogFactory.getLog(log));
167        }
168    
169        /**
170         * Creates an error handler which just logs errors
171         */
172        public LoggingErrorHandlerBuilder loggingErrorHandler(Log log) {
173            return new LoggingErrorHandlerBuilder(log);
174        }
175    
176        /**
177         * Creates an error handler which just logs errors
178         */
179        public LoggingErrorHandlerBuilder loggingErrorHandler(Log log, LoggingLevel level) {
180            return new LoggingErrorHandlerBuilder(log, level);
181        }
182    
183        public DeadLetterChannelBuilder deadLetterChannel() {
184            return new DeadLetterChannelBuilder();
185        }
186    
187        public DeadLetterChannelBuilder deadLetterChannel(String deadLetterUri) {
188            return deadLetterChannel(endpoint(deadLetterUri));
189        }
190    
191        public DeadLetterChannelBuilder deadLetterChannel(Endpoint deadLetterEndpoint) {
192            return new DeadLetterChannelBuilder(new SendProcessor(deadLetterEndpoint));
193        }
194    
195        // Properties
196        // -------------------------------------------------------------------------
197        public CamelContext getContext() {
198            return context;
199        }
200    
201        public void setContext(CamelContext context) {
202            this.context = context;
203        }
204    
205        public ErrorHandlerBuilder getErrorHandlerBuilder() {
206            if (errorHandlerBuilder == null) {
207                errorHandlerBuilder = createErrorHandlerBuilder();
208            }
209            return errorHandlerBuilder;
210        }
211    
212        protected ErrorHandlerBuilder createErrorHandlerBuilder() {
213            if (isInheritErrorHandler()) {
214                return new DeadLetterChannelBuilder();
215            } else {
216                return new NoErrorHandlerBuilder();
217            }
218        }
219    
220        /**
221         * Sets the error handler to use with processors created by this builder
222         */
223        public void setErrorHandlerBuilder(ErrorHandlerBuilder errorHandlerBuilder) {
224            this.errorHandlerBuilder = errorHandlerBuilder;
225        }
226    
227        public boolean isInheritErrorHandler() {
228            return inheritErrorHandler;
229        }
230    
231        public void setInheritErrorHandler(boolean inheritErrorHandler) {
232            this.inheritErrorHandler = inheritErrorHandler;
233        }
234    }