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