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.NoSuchEndpointException;
027 import org.apache.camel.model.LoggingLevel;
028 import org.apache.camel.processor.SendProcessor;
029 import org.apache.camel.util.ObjectHelper;
030 import org.apache.commons.logging.Log;
031 import org.apache.commons.logging.LogFactory;
032
033 /**
034 * Base class for implementation inheritance for different clauses in the <a
035 * href="http://activemq.apache.org/camel/dsl.html">Java DSL</a>
036 *
037 * @version $Revision: 13811 $
038 */
039 public abstract class BuilderSupport {
040 private CamelContext context;
041 private ErrorHandlerBuilder errorHandlerBuilder;
042 private boolean inheritErrorHandler = true;
043
044 protected BuilderSupport(CamelContext context) {
045 this.context = context;
046 }
047
048 protected BuilderSupport(BuilderSupport parent) {
049 this.context = parent.getContext();
050 this.inheritErrorHandler = parent.inheritErrorHandler;
051 if (inheritErrorHandler && parent.errorHandlerBuilder != null) {
052 this.errorHandlerBuilder = parent.errorHandlerBuilder.copy();
053 }
054 }
055
056 // Builder methods
057 // -------------------------------------------------------------------------
058
059 /**
060 * Returns a value builder for the given header
061 */
062 public ValueBuilder header(String name) {
063 return Builder.header(name);
064 }
065
066 /**
067 * Returns a predicate and value builder for the inbound body on an exchange
068 */
069 public ValueBuilder body() {
070 return Builder.body();
071 }
072
073 /**
074 * Returns a predicate and value builder for the inbound message body as a
075 * specific type
076 */
077 public <T> ValueBuilder body(Class<T> type) {
078 return Builder.bodyAs(type);
079 }
080
081 /**
082 * Returns a predicate and value builder for the outbound body on an
083 * exchange
084 */
085 public ValueBuilder outBody() {
086 return Builder.outBody();
087 }
088
089 /**
090 * Returns a predicate and value builder for the outbound message body as a
091 * specific type
092 */
093 public <T> ValueBuilder outBody(Class<T> type) {
094 return Builder.outBodyAs(type);
095 }
096
097 /**
098 * Returns a predicate and value builder for the fault body on an
099 * exchange
100 */
101 public ValueBuilder faultBody() {
102 return Builder.faultBody();
103 }
104
105 /**
106 * Returns a predicate and value builder for the fault message body as a
107 * specific type
108 */
109 public <T> ValueBuilder faultBodyAs(Class<T> type) {
110 return Builder.faultBodyAs(type);
111 }
112
113 /**
114 * Returns a value builder for the given property
115 */
116 public ValueBuilder property(String name) {
117 return Builder.property(name);
118 }
119
120 /**
121 * Returns a value builder for the given system property
122 */
123 public ValueBuilder systemProperty(String name) {
124 return Builder.systemProperty(name);
125 }
126
127 /**
128 * Returns a value builder for the given system property
129 */
130 public ValueBuilder systemProperty(String name, String defaultValue) {
131 return Builder.systemProperty(name, defaultValue);
132 }
133
134 /**
135 * Returns a constant expression value builder
136 */
137 public ValueBuilder constant(Object value) {
138 return Builder.constant(value);
139 }
140
141 /**
142 * Returns an expression value builder that replaces all occurrences of the
143 * regular expression with the given replacement
144 */
145 public ValueBuilder regexReplaceAll(Expression content, String regex, String replacement) {
146 return Builder.regexReplaceAll(content, regex, replacement);
147 }
148
149 /**
150 * Returns an expression value builder that replaces all occurrences of the
151 * regular expression with the given replacement
152 */
153 public ValueBuilder regexReplaceAll(Expression content, String regex, Expression replacement) {
154 return Builder.regexReplaceAll(content, regex, replacement);
155 }
156
157 /**
158 * Resolves the given URI to an endpoint
159 *
160 * @throws NoSuchEndpointException if the endpoint URI could not be resolved
161 */
162 public Endpoint endpoint(String uri) throws NoSuchEndpointException {
163 ObjectHelper.notNull(uri, "uri");
164 Endpoint endpoint = getContext().getEndpoint(uri);
165 if (endpoint == null) {
166 throw new NoSuchEndpointException(uri);
167 }
168 return endpoint;
169 }
170
171 /**
172 * Resolves the given URI to an endpoint of the specified type
173 *
174 * @throws NoSuchEndpointException if the endpoint URI could not be resolved
175 */
176 public <T extends Endpoint> T endpoint(String uri, Class<T> type) throws NoSuchEndpointException {
177 ObjectHelper.notNull(uri, "uri");
178 T endpoint = getContext().getEndpoint(uri, type);
179 if (endpoint == null) {
180 throw new NoSuchEndpointException(uri);
181 }
182 return endpoint;
183 }
184
185 /**
186 * Resolves the list of URIs into a list of {@link Endpoint} instances
187 *
188 * @throws NoSuchEndpointException if an endpoint URI could not be resolved
189 */
190 public List<Endpoint> endpoints(String... uris) throws NoSuchEndpointException {
191 List<Endpoint> endpoints = new ArrayList<Endpoint>();
192 for (String uri : uris) {
193 endpoints.add(endpoint(uri));
194 }
195 return endpoints;
196 }
197
198 /**
199 * Helper method to create a list of {@link Endpoint} instances
200 */
201 public List<Endpoint> endpoints(Endpoint... endpoints) {
202 List<Endpoint> answer = new ArrayList<Endpoint>();
203 answer.addAll(Arrays.asList(endpoints));
204 return answer;
205 }
206
207 /**
208 * Creates a disabled error handler for removing the default error handler
209 */
210 public NoErrorHandlerBuilder noErrorHandler() {
211 return new NoErrorHandlerBuilder();
212 }
213
214 /**
215 * Creates an error handler which just logs errors
216 */
217 public LoggingErrorHandlerBuilder loggingErrorHandler() {
218 return new LoggingErrorHandlerBuilder();
219 }
220
221 /**
222 * Creates an error handler which just logs errors
223 */
224 public LoggingErrorHandlerBuilder loggingErrorHandler(String log) {
225 return loggingErrorHandler(LogFactory.getLog(log));
226 }
227
228 /**
229 * Creates an error handler which just logs errors
230 */
231 public LoggingErrorHandlerBuilder loggingErrorHandler(Log log) {
232 return new LoggingErrorHandlerBuilder(log);
233 }
234
235 /**
236 * Creates an error handler which just logs errors
237 */
238 public LoggingErrorHandlerBuilder loggingErrorHandler(Log log, LoggingLevel level) {
239 return new LoggingErrorHandlerBuilder(log, level);
240 }
241
242 public DeadLetterChannelBuilder deadLetterChannel() {
243 return new DeadLetterChannelBuilder();
244 }
245
246 public DeadLetterChannelBuilder deadLetterChannel(String deadLetterUri) {
247 return deadLetterChannel(endpoint(deadLetterUri));
248 }
249
250 public DeadLetterChannelBuilder deadLetterChannel(Endpoint deadLetterEndpoint) {
251 return new DeadLetterChannelBuilder(new SendProcessor(deadLetterEndpoint));
252 }
253
254 // Properties
255 // -------------------------------------------------------------------------
256 public CamelContext getContext() {
257 return context;
258 }
259
260 public void setContext(CamelContext context) {
261 this.context = context;
262 }
263
264 public ErrorHandlerBuilder getErrorHandlerBuilder() {
265 if (errorHandlerBuilder == null) {
266 errorHandlerBuilder = createErrorHandlerBuilder();
267 }
268 return errorHandlerBuilder;
269 }
270
271 protected ErrorHandlerBuilder createErrorHandlerBuilder() {
272 if (isInheritErrorHandler()) {
273 return new DeadLetterChannelBuilder();
274 } else {
275 return new NoErrorHandlerBuilder();
276 }
277 }
278
279 /**
280 * Sets the error handler to use with processors created by this builder
281 */
282 public void setErrorHandlerBuilder(ErrorHandlerBuilder errorHandlerBuilder) {
283 this.errorHandlerBuilder = errorHandlerBuilder;
284 }
285
286 public boolean isInheritErrorHandler() {
287 return inheritErrorHandler;
288 }
289
290 public void setInheritErrorHandler(boolean inheritErrorHandler) {
291 this.inheritErrorHandler = inheritErrorHandler;
292 }
293 }