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.model;
018
019 import java.util.ArrayList;
020 import java.util.Arrays;
021 import java.util.Collection;
022 import java.util.Collections;
023 import java.util.Comparator;
024 import java.util.LinkedList;
025 import java.util.List;
026
027 import javax.xml.bind.annotation.XmlAccessType;
028 import javax.xml.bind.annotation.XmlAccessorType;
029 import javax.xml.bind.annotation.XmlAttribute;
030 import javax.xml.bind.annotation.XmlTransient;
031
032 import org.apache.camel.Channel;
033 import org.apache.camel.Endpoint;
034 import org.apache.camel.ExchangePattern;
035 import org.apache.camel.Expression;
036 import org.apache.camel.Predicate;
037 import org.apache.camel.Processor;
038 import org.apache.camel.Route;
039 import org.apache.camel.builder.DataFormatClause;
040 import org.apache.camel.builder.ErrorHandlerBuilder;
041 import org.apache.camel.builder.ErrorHandlerBuilderRef;
042 import org.apache.camel.builder.ExpressionBuilder;
043 import org.apache.camel.builder.ExpressionClause;
044 import org.apache.camel.builder.ProcessorBuilder;
045 import org.apache.camel.model.language.ConstantExpression;
046 import org.apache.camel.model.language.ExpressionDefinition;
047 import org.apache.camel.model.language.LanguageExpression;
048 import org.apache.camel.processor.DefaultChannel;
049 import org.apache.camel.processor.InterceptEndpointProcessor;
050 import org.apache.camel.processor.Pipeline;
051 import org.apache.camel.processor.aggregate.AggregationCollection;
052 import org.apache.camel.processor.aggregate.AggregationStrategy;
053 import org.apache.camel.processor.loadbalancer.LoadBalancer;
054 import org.apache.camel.spi.DataFormat;
055 import org.apache.camel.spi.IdempotentRepository;
056 import org.apache.camel.spi.InterceptStrategy;
057 import org.apache.camel.spi.Policy;
058 import org.apache.camel.spi.RouteContext;
059 import org.apache.camel.spi.TransactedPolicy;
060 import org.apache.commons.logging.Log;
061 import org.apache.commons.logging.LogFactory;
062
063 import static org.apache.camel.builder.Builder.body;
064
065 /**
066 * Base class for processor types that most XML types extend.
067 *
068 * @version $Revision: 794544 $
069 */
070 @XmlAccessorType(XmlAccessType.PROPERTY)
071 public abstract class ProcessorDefinition<Type extends ProcessorDefinition> extends OptionalIdentifiedType<Type> implements Block {
072 private static final transient Log LOG = LogFactory.getLog(ProcessorDefinition.class);
073 private ErrorHandlerBuilder errorHandlerBuilder;
074 private NodeFactory nodeFactory;
075 private final LinkedList<Block> blocks = new LinkedList<Block>();
076 private ProcessorDefinition parent;
077 private String errorHandlerRef;
078 private final List<InterceptStrategy> interceptStrategies = new ArrayList<InterceptStrategy>();
079
080 // else to use an optional attribute in JAXB2
081 public abstract List<ProcessorDefinition> getOutputs();
082
083
084 public Processor createProcessor(RouteContext routeContext) throws Exception {
085 throw new UnsupportedOperationException("Not implemented yet for class: " + getClass().getName());
086 }
087
088 public Processor createOutputsProcessor(RouteContext routeContext) throws Exception {
089 Collection<ProcessorDefinition> outputs = getOutputs();
090 return createOutputsProcessor(routeContext, outputs);
091 }
092
093 @SuppressWarnings("unchecked")
094 public void addOutput(ProcessorDefinition processorType) {
095 processorType.setParent(this);
096 configureChild(processorType);
097 if (blocks.isEmpty()) {
098 getOutputs().add(processorType);
099 } else {
100 Block block = blocks.getLast();
101 block.addOutput(processorType);
102 }
103 }
104
105 public void clearOutput() {
106 getOutputs().clear();
107 blocks.clear();
108 }
109
110 public void addRoutes(RouteContext routeContext, Collection<Route> routes) throws Exception {
111 Processor processor = makeProcessor(routeContext);
112 if (processor == null) {
113 // no processor to add
114 return;
115 }
116
117 if (!routeContext.isRouteAdded()) {
118 boolean endpointInterceptor = false;
119
120 // are we routing to an endpoint interceptor, if so we should not add it as an event driven
121 // processor as we use the producer to trigger the interceptor
122 if (processor instanceof Channel) {
123 Channel channel = (Channel) processor;
124 Processor next = channel.getNextProcessor();
125 if (next instanceof InterceptEndpointProcessor) {
126 endpointInterceptor = true;
127 }
128 }
129
130 // only add regular processors as event driven
131 if (endpointInterceptor) {
132 if (LOG.isDebugEnabled()) {
133 LOG.debug("Endpoint interceptor should not be added as an event driven consumer route: " + processor);
134 }
135 } else {
136 if (LOG.isTraceEnabled()) {
137 LOG.trace("Adding event driven processor: " + processor);
138 }
139 routeContext.addEventDrivenProcessor(processor);
140 }
141
142 }
143 }
144
145 /**
146 * Wraps the child processor in whatever necessary interceptors and error handlers
147 */
148 public Processor wrapProcessor(RouteContext routeContext, Processor processor) throws Exception {
149 // dont double wrap
150 if (processor instanceof Channel) {
151 return processor;
152 }
153 return wrapChannel(routeContext, processor);
154 }
155
156 protected Processor wrapChannel(RouteContext routeContext, Processor processor) throws Exception {
157 // put a channel inbetween this and each output to control the route flow logic
158 Channel channel = createChannel(routeContext);
159 channel.setNextProcessor(processor);
160
161 // add interceptor strategies to the channel
162 channel.addInterceptStrategies(routeContext.getCamelContext().getInterceptStrategies());
163 channel.addInterceptStrategies(routeContext.getInterceptStrategies());
164 channel.addInterceptStrategies(this.getInterceptStrategies());
165
166 // init the channel
167 channel.initChannel(this, routeContext);
168
169 // set the error handler, must be done after init as we can set the error handler as first in the chain
170 if (this instanceof TryDefinition || this instanceof CatchDefinition || this instanceof FinallyDefinition) {
171 // do not use error handler for try .. catch .. finally blocks as it will handle errors itself
172 return channel;
173 } else {
174 // regular definition so add the error handler
175 Processor output = channel.getOutput();
176 Processor errorHandler = getErrorHandlerBuilder().createErrorHandler(routeContext, output);
177 channel.setErrorHandler(errorHandler);
178 return channel;
179 }
180 }
181
182 /**
183 * Creates a new instance of some kind of composite processor which defaults
184 * to using a {@link Pipeline} but derived classes could change the behaviour
185 */
186 protected Processor createCompositeProcessor(RouteContext routeContext, List<Processor> list) {
187 return new Pipeline(list);
188 }
189
190 /**
191 * Creates a new instance of the {@link Channel}.
192 */
193 protected Channel createChannel(RouteContext routeContext) {
194 return new DefaultChannel();
195 }
196
197 protected Processor createOutputsProcessor(RouteContext routeContext, Collection<ProcessorDefinition> outputs) throws Exception {
198 List<Processor> list = new ArrayList<Processor>();
199 for (ProcessorDefinition output : outputs) {
200 Processor processor = output.createProcessor(routeContext);
201 if (output instanceof Channel && processor == null) {
202 continue;
203 }
204
205 Processor channel = wrapChannel(routeContext, processor);
206 list.add(channel);
207 }
208
209 // if more than one output wrap than in a composite processor else just keep it as is
210 Processor processor = null;
211 if (!list.isEmpty()) {
212 if (list.size() == 1) {
213 processor = list.get(0);
214 } else {
215 processor = createCompositeProcessor(routeContext, list);
216 }
217 }
218
219 return processor;
220 }
221
222 /**
223 * Creates the processor and wraps it in any necessary interceptors and error handlers
224 */
225 protected Processor makeProcessor(RouteContext routeContext) throws Exception {
226 Processor processor = createProcessor(routeContext);
227 if (processor == null) {
228 // no processor to make
229 return null;
230 }
231 return wrapProcessor(routeContext, processor);
232 }
233
234 protected ErrorHandlerBuilder createErrorHandlerBuilder() {
235 if (errorHandlerRef != null) {
236 return new ErrorHandlerBuilderRef(errorHandlerRef);
237 }
238
239 // return a reference to the default error handler
240 return new ErrorHandlerBuilderRef(ErrorHandlerBuilderRef.DEFAULT_ERROR_HANDLER_BUILDER);
241 }
242
243 protected void configureChild(ProcessorDefinition output) {
244 output.setNodeFactory(getNodeFactory());
245 output.setErrorHandlerBuilder(getErrorHandlerBuilder());
246 }
247
248 // Fluent API
249 // -------------------------------------------------------------------------
250
251 /**
252 * Sends the exchange to the given endpoint
253 *
254 * @param uri the endpoint to send to
255 * @return the builder
256 */
257 @SuppressWarnings("unchecked")
258 public Type to(String uri) {
259 addOutput(new ToDefinition(uri));
260 return (Type) this;
261 }
262
263 /**
264 * Sends the exchange to the given endpoint
265 *
266 * @param uri the String formatted endpoint uri to send to
267 * @param args arguments for the string formatting of the uri
268 * @return the builder
269 */
270 @SuppressWarnings("unchecked")
271 public Type toF(String uri, Object... args) {
272 addOutput(new ToDefinition(String.format(uri, args)));
273 return (Type) this;
274 }
275
276
277 /**
278 * Sends the exchange to the given endpoint
279 *
280 * @param endpoint the endpoint to send to
281 * @return the builder
282 */
283 @SuppressWarnings("unchecked")
284 public Type to(Endpoint endpoint) {
285 addOutput(new ToDefinition(endpoint));
286 return (Type) this;
287 }
288
289 /**
290 * Sends the exchange with certain exchange pattern to the given endpoint
291 *
292 * @param pattern the pattern to use for the message exchange
293 * @param uri the endpoint to send to
294 * @return the builder
295 */
296 @SuppressWarnings("unchecked")
297 public Type to(ExchangePattern pattern, String uri) {
298 addOutput(new ToDefinition(uri, pattern));
299 return (Type) this;
300 }
301
302
303 /**
304 * Sends the exchange with certain exchange pattern to the given endpoint
305 *
306 * @param pattern the pattern to use for the message exchange
307 * @param endpoint the endpoint to send to
308 * @return the builder
309 */
310 @SuppressWarnings("unchecked")
311 public Type to(ExchangePattern pattern, Endpoint endpoint) {
312 addOutput(new ToDefinition(endpoint, pattern));
313 return (Type) this;
314 }
315
316 /**
317 * Sends the exchange to a list of endpoints
318 *
319 * @param uris list of endpoints to send to
320 * @return the builder
321 */
322 @SuppressWarnings("unchecked")
323 public Type to(String... uris) {
324 for (String uri : uris) {
325 addOutput(new ToDefinition(uri));
326 }
327 return (Type) this;
328 }
329
330
331 /**
332 * Sends the exchange to a list of endpoints
333 *
334 * @param endpoints list of endpoints to send to
335 * @return the builder
336 */
337 @SuppressWarnings("unchecked")
338 public Type to(Endpoint... endpoints) {
339 for (Endpoint endpoint : endpoints) {
340 addOutput(new ToDefinition(endpoint));
341 }
342 return (Type) this;
343 }
344
345 /**
346 * Sends the exchange to a list of endpoints
347 *
348 * @param endpoints list of endpoints to send to
349 * @return the builder
350 */
351 @SuppressWarnings("unchecked")
352 public Type to(Iterable<Endpoint> endpoints) {
353 for (Endpoint endpoint : endpoints) {
354 addOutput(new ToDefinition(endpoint));
355 }
356 return (Type) this;
357 }
358
359
360 /**
361 * Sends the exchange to a list of endpoints
362 *
363 * @param pattern the pattern to use for the message exchanges
364 * @param uris list of endpoints to send to
365 * @return the builder
366 */
367 @SuppressWarnings("unchecked")
368 public Type to(ExchangePattern pattern, String... uris) {
369 for (String uri : uris) {
370 addOutput(new ToDefinition(uri, pattern));
371 }
372 return (Type) this;
373 }
374
375 /**
376 * Sends the exchange to a list of endpoints
377 *
378 * @param pattern the pattern to use for the message exchanges
379 * @param endpoints list of endpoints to send to
380 * @return the builder
381 */
382 @SuppressWarnings("unchecked")
383 public Type to(ExchangePattern pattern, Endpoint... endpoints) {
384 for (Endpoint endpoint : endpoints) {
385 addOutput(new ToDefinition(endpoint, pattern));
386 }
387 return (Type) this;
388 }
389
390 /**
391 * Sends the exchange to a list of endpoints
392 *
393 * @param pattern the pattern to use for the message exchanges
394 * @param endpoints list of endpoints to send to
395 * @return the builder
396 */
397 @SuppressWarnings("unchecked")
398 public Type to(ExchangePattern pattern, Iterable<Endpoint> endpoints) {
399 for (Endpoint endpoint : endpoints) {
400 addOutput(new ToDefinition(endpoint, pattern));
401 }
402 return (Type) this;
403 }
404
405
406 /**
407 * <a href="http://camel.apache.org/exchange-pattern.html">ExchangePattern:</a>
408 * set the ExchangePattern {@link ExchangePattern} into the exchange
409 *
410 * @param exchangePattern instance of {@link ExchangePattern}
411 * @return the builder
412 */
413 @SuppressWarnings("unchecked")
414 public Type setExchangePattern(ExchangePattern exchangePattern) {
415 addOutput(new SetExchangePatternDefinition(exchangePattern));
416 return (Type) this;
417 }
418
419 /**
420 * <a href="http://camel.apache.org/exchange-pattern.html">ExchangePattern:</a>
421 * set the exchange's ExchangePattern {@link ExchangePattern} to be InOnly
422 *
423 *
424 * @return the builder
425 */
426 public Type inOnly() {
427 return setExchangePattern(ExchangePattern.InOnly);
428 }
429
430 /**
431 * Sends the message to the given endpoint using an
432 * <a href="http://camel.apache.org/event-message.html">Event Message</a> or
433 * <a href="http://camel.apache.org/exchange-pattern.html">InOnly exchange pattern</a>
434 *
435 * @param uri The endpoint uri which is used for sending the exchange
436 * @return the builder
437 */
438 public Type inOnly(String uri) {
439 return to(ExchangePattern.InOnly, uri);
440 }
441
442 /**
443 * Sends the message to the given endpoint using an
444 * <a href="http://camel.apache.org/event-message.html">Event Message</a> or
445 * <a href="http://camel.apache.org/exchange-pattern.html">InOnly exchange pattern</a>
446 *
447 * @param endpoint The endpoint which is used for sending the exchange
448 * @return the builder
449 */
450 public Type inOnly(Endpoint endpoint) {
451 return to(ExchangePattern.InOnly, endpoint);
452 }
453
454
455 /**
456 * Sends the message to the given endpoints using an
457 * <a href="http://camel.apache.org/event-message.html">Event Message</a> or
458 * <a href="http://camel.apache.org/exchange-pattern.html">InOnly exchange pattern</a>
459 *
460 * @param uris list of endpoints to send to
461 * @return the builder
462 */
463 public Type inOnly(String... uris) {
464 return to(ExchangePattern.InOnly, uris);
465 }
466
467
468 /**
469 * Sends the message to the given endpoints using an
470 * <a href="http://camel.apache.org/event-message.html">Event Message</a> or
471 * <a href="http://camel.apache.org/exchange-pattern.html">InOnly exchange pattern</a>
472 *
473 * @param endpoints list of endpoints to send to
474 * @return the builder
475 */
476 public Type inOnly(Endpoint... endpoints) {
477 return to(ExchangePattern.InOnly, endpoints);
478 }
479
480 /**
481 * Sends the message to the given endpoints using an
482 * <a href="http://camel.apache.org/event-message.html">Event Message</a> or
483 * <a href="http://camel.apache.org/exchange-pattern.html">InOnly exchange pattern</a>
484 *
485 * @param endpoints list of endpoints to send to
486 * @return the builder
487 */
488 public Type inOnly(Iterable<Endpoint> endpoints) {
489 return to(ExchangePattern.InOnly, endpoints);
490 }
491
492
493 /**
494 * <a href="http://camel.apache.org/exchange-pattern.html">ExchangePattern:</a>
495 * set the exchange's ExchangePattern {@link ExchangePattern} to be InOut
496 *
497 *
498 * @return the builder
499 */
500 public Type inOut() {
501 return setExchangePattern(ExchangePattern.InOut);
502 }
503
504 /**
505 * Sends the message to the given endpoint using an
506 * <a href="http://camel.apache.org/request-reply.html">Request Reply</a> or
507 * <a href="http://camel.apache.org/exchange-pattern.html">InOut exchange pattern</a>
508 *
509 * @param uri The endpoint uri which is used for sending the exchange
510 * @return the builder
511 */
512 public Type inOut(String uri) {
513 return to(ExchangePattern.InOut, uri);
514 }
515
516
517 /**
518 * Sends the message to the given endpoint using an
519 * <a href="http://camel.apache.org/request-reply.html">Request Reply</a> or
520 * <a href="http://camel.apache.org/exchange-pattern.html">InOut exchange pattern</a>
521 *
522 * @param endpoint The endpoint which is used for sending the exchange
523 * @return the builder
524 */
525 public Type inOut(Endpoint endpoint) {
526 return to(ExchangePattern.InOut, endpoint);
527 }
528
529 /**
530 * Sends the message to the given endpoints using an
531 * <a href="http://camel.apache.org/request-reply.html">Request Reply</a> or
532 * <a href="http://camel.apache.org/exchange-pattern.html">InOut exchange pattern</a>
533 *
534 * @param uris list of endpoints to send to
535 * @return the builder
536 */
537 public Type inOut(String... uris) {
538 return to(ExchangePattern.InOut, uris);
539 }
540
541
542 /**
543 * Sends the message to the given endpoints using an
544 * <a href="http://camel.apache.org/request-reply.html">Request Reply</a> or
545 * <a href="http://camel.apache.org/exchange-pattern.html">InOut exchange pattern</a>
546 *
547 * @param endpoints list of endpoints to send to
548 * @return the builder
549 */
550 public Type inOut(Endpoint... endpoints) {
551 return to(ExchangePattern.InOut, endpoints);
552 }
553
554 /**
555 * Sends the message to the given endpoints using an
556 * <a href="http://camel.apache.org/request-reply.html">Request Reply</a> or
557 * <a href="http://camel.apache.org/exchange-pattern.html">InOut exchange pattern</a>
558 *
559 * @param endpoints list of endpoints to send to
560 * @return the builder
561 */
562 public Type inOut(Iterable<Endpoint> endpoints) {
563 return to(ExchangePattern.InOut, endpoints);
564 }
565
566 /**
567 * Sets the id of this node
568 *
569 * @param id the id
570 * @return the builder
571 */
572 @SuppressWarnings("unchecked")
573 public Type id(String id) {
574 if (getOutputs().isEmpty()) {
575 // set id on this
576 setId(id);
577 } else {
578 // set it on last output as this is what the user means to do
579 getOutputs().get(getOutputs().size() - 1).setId(id);
580 }
581
582 return (Type) this;
583 }
584
585 /**
586 * <a href="http://camel.apache.org/multicast.html">Multicast EIP:</a>
587 * Multicasts messages to all its child outputs; so that each processor and
588 * destination gets a copy of the original message to avoid the processors
589 * interfering with each other.
590 *
591 * @return the builder
592 */
593 public MulticastDefinition multicast() {
594 MulticastDefinition answer = new MulticastDefinition();
595 addOutput(answer);
596 return answer;
597 }
598
599 /**
600 * <a href="http://camel.apache.org/multicast.html">Multicast EIP:</a>
601 * Multicasts messages to all its child outputs; so that each processor and
602 * destination gets a copy of the original message to avoid the processors
603 * interfering with each other.
604 *
605 * @param aggregationStrategy the strategy used to aggregate responses for
606 * every part
607 * @param parallelProcessing if is <tt>true</tt> camel will fork thread to call the endpoint producer
608 * @return the builder
609 */
610 public MulticastDefinition multicast(AggregationStrategy aggregationStrategy, boolean parallelProcessing) {
611 MulticastDefinition answer = new MulticastDefinition();
612 addOutput(answer);
613 answer.setAggregationStrategy(aggregationStrategy);
614 answer.setParallelProcessing(parallelProcessing);
615 return answer;
616 }
617
618 /**
619 * <a href="http://camel.apache.org/multicast.html">Multicast EIP:</a>
620 * Multicasts messages to all its child outputs; so that each processor and
621 * destination gets a copy of the original message to avoid the processors
622 * interfering with each other.
623 *
624 * @param aggregationStrategy the strategy used to aggregate responses for
625 * every part
626 * @return the builder
627 */
628 public MulticastDefinition multicast(AggregationStrategy aggregationStrategy) {
629 MulticastDefinition answer = new MulticastDefinition();
630 addOutput(answer);
631 answer.setAggregationStrategy(aggregationStrategy);
632 return answer;
633 }
634
635 /**
636 * <a href="http://camel.apache.org/pipes-nd-filters.html">Pipes and Filters EIP:</a>
637 * Creates a {@link Pipeline} of the list of endpoints so that the message
638 * will get processed by each endpoint in turn and for request/response the
639 * output of one endpoint will be the input of the next endpoint
640 *
641 * @param uris list of endpoints
642 * @return the builder
643 */
644 public Type pipeline(String... uris) {
645 return to(uris);
646 }
647
648 /**
649 * <a href="http://camel.apache.org/pipes-nd-filters.html">Pipes and Filters EIP:</a>
650 * Creates a {@link Pipeline} of the list of endpoints so that the message
651 * will get processed by each endpoint in turn and for request/response the
652 * output of one endpoint will be the input of the next endpoint
653 *
654 * @param endpoints list of endpoints
655 * @return the builder
656 */
657 public Type pipeline(Endpoint... endpoints) {
658 return to(endpoints);
659 }
660
661 /**
662 * <a href="http://camel.apache.org/pipes-nd-filters.html">Pipes and Filters EIP:</a>
663 * Creates a {@link Pipeline} of the list of endpoints so that the message
664 * will get processed by each endpoint in turn and for request/response the
665 * output of one endpoint will be the input of the next endpoint
666 *
667 * @param endpoints list of endpoints
668 * @return the builder
669 */
670 public Type pipeline(Collection<Endpoint> endpoints) {
671 return to(endpoints);
672 }
673
674 /**
675 * Leverages a thread pool for multi threading processing exchanges.
676 * <p/>
677 * The caller thread will either wait for the async route
678 * to complete or imeddiately continue. If continue the OUT message will
679 * contain a {@link java.util.concurrent.Future} handle so you can get the real response
680 * later using this handle.
681 * <p/>
682 * Will default <tt>Always</tt> wait for the async route to complete, but this behavior can be overriden by:
683 * <ul>
684 * <li>Configuring the <tt>waitForTaskToComplete</tt> option</li>
685 * <li>Provide an IN header with the key {@link org.apache.camel.Exchange#ASYNC_WAIT} with the
686 * value containing a type {@link org.apache.camel.WaitForTaskToComplete}. The header will take precedence, if provided.</li>
687 * </ul>
688 *
689 * @return the builder
690 */
691 public ThreadsDefinition threads() {
692 ThreadsDefinition answer = new ThreadsDefinition();
693 addOutput(answer);
694 return answer;
695 }
696
697 /**
698 * Leverages a thread pool for multi threading processing exchanges.
699 * <p/>
700 * See {@link #threads()} for more details.
701 *
702 * @param poolSize the core pool size
703 * @return the builder
704 */
705 public ThreadsDefinition threads(int poolSize) {
706 ThreadsDefinition answer = threads();
707 answer.setPoolSize(poolSize);
708 return answer;
709 }
710
711 /**
712 * Wraps the sub route using AOP allowing you to do before and after work (AOP around).
713 *
714 * @return the builder
715 */
716 public AOPDefinition aop() {
717 AOPDefinition answer = new AOPDefinition();
718 addOutput(answer);
719 return answer;
720 }
721
722 /**
723 * Ends the current block
724 *
725 * @return the builder
726 */
727 @SuppressWarnings("unchecked")
728 public ProcessorDefinition<? extends ProcessorDefinition> end() {
729 // when using doTry .. doCatch .. doFinally we should always
730 // end the try definition to avoid having to use 2 x end() in the route
731 // this is counter intuitive for end users
732 if (this instanceof TryDefinition) {
733 popBlock();
734 }
735
736 if (blocks.isEmpty()) {
737 if (parent == null) {
738 return this;
739 }
740 return parent;
741 }
742 popBlock();
743 return this;
744 }
745
746 /**
747 * <a href="http://camel.apache.org/idempotent-consumer.html">Idempotent consumer EIP:</a>
748 * Creates an {@link org.apache.camel.processor.idempotent.IdempotentConsumer IdempotentConsumer}
749 * to avoid duplicate messages
750 *
751 * @return the builder
752 */
753 public IdempotentConsumerDefinition idempotentConsumer() {
754 IdempotentConsumerDefinition answer = new IdempotentConsumerDefinition();
755 addOutput(answer);
756 return answer;
757 }
758
759 /**
760 * <a href="http://camel.apache.org/idempotent-consumer.html">Idempotent consumer EIP:</a>
761 * Creates an {@link org.apache.camel.processor.idempotent.IdempotentConsumer IdempotentConsumer}
762 * to avoid duplicate messages
763 *
764 * @param messageIdExpression expression to test of duplicate messages
765 * @param idempotentRepository the repository to use for duplicate chedck
766 * @return the builder
767 */
768 public IdempotentConsumerDefinition idempotentConsumer(Expression messageIdExpression,
769 IdempotentRepository idempotentRepository) {
770 IdempotentConsumerDefinition answer = new IdempotentConsumerDefinition(messageIdExpression, idempotentRepository);
771 addOutput(answer);
772 return answer;
773 }
774
775 /**
776 * <a href="http://camel.apache.org/idempotent-consumer.html">Idempotent consumer EIP:</a>
777 * Creates an {@link org.apache.camel.processor.idempotent.IdempotentConsumer IdempotentConsumer}
778 * to avoid duplicate messages
779 *
780 * @param idempotentRepository the repository to use for duplicate chedck
781 * @return the builder used to create the expression
782 */
783 public ExpressionClause<IdempotentConsumerDefinition> idempotentConsumer(IdempotentRepository idempotentRepository) {
784 IdempotentConsumerDefinition answer = new IdempotentConsumerDefinition();
785 answer.setMessageIdRepository(idempotentRepository);
786 addOutput(answer);
787 return ExpressionClause.createAndSetExpression(answer);
788 }
789
790 /**
791 * <a href="http://camel.apache.org/message-filter.html">Message Filter EIP:</a>
792 * Creates a predicate expression which only if it is <tt>true</tt> then the
793 * exchange is forwarded to the destination
794 *
795 * @return the clause used to create the filter expression
796 */
797 public ExpressionClause<FilterDefinition> filter() {
798 FilterDefinition filter = new FilterDefinition();
799 addOutput(filter);
800 return ExpressionClause.createAndSetExpression(filter);
801 }
802
803 /**
804 * <a href="http://camel.apache.org/message-filter.html">Message Filter EIP:</a>
805 * Creates a predicate which is applied and only if it is <tt>true</tt> then the
806 * exchange is forwarded to the destination
807 *
808 * @param predicate predicate to use
809 * @return the builder
810 */
811 public FilterDefinition filter(Predicate predicate) {
812 FilterDefinition filter = new FilterDefinition(predicate);
813 addOutput(filter);
814 return filter;
815 }
816
817 /**
818 * <a href="http://camel.apache.org/message-filter.html">Message Filter EIP:</a>
819 * Creates a predicate expression which only if it is <tt>true</tt> then the
820 * exchange is forwarded to the destination
821 *
822 * @param expression the predicate expression to use
823 * @return the builder
824 */
825 public FilterDefinition filter(ExpressionDefinition expression) {
826 FilterDefinition filter = getNodeFactory().createFilter();
827 filter.setExpression(expression);
828 addOutput(filter);
829 return filter;
830 }
831
832 /**
833 * <a href="http://camel.apache.org/message-filter.html">Message Filter EIP:</a>
834 * Creates a predicate language expression which only if it is <tt>true</tt> then the
835 * exchange is forwarded to the destination
836 *
837 * @param language language for expression
838 * @param expression the expression
839 * @return the builder
840 */
841 public FilterDefinition filter(String language, String expression) {
842 return filter(new LanguageExpression(language, expression));
843 }
844
845 /**
846 * <a href="http://camel.apache.org/load-balancer.html">Load Balancer EIP:</a>
847 * Creates a loadbalance
848 *
849 * @return the builder
850 */
851 public LoadBalanceDefinition loadBalance() {
852 LoadBalanceDefinition answer = new LoadBalanceDefinition();
853 addOutput(answer);
854 return answer;
855 }
856
857 /**
858 * <a href="http://camel.apache.org/load-balancer.html">Load Balancer EIP:</a>
859 * Creates a loadbalance
860 *
861 * @param loadBalancer a custom load balancer to use
862 * @return the builder
863 */
864 public LoadBalanceDefinition loadBalance(LoadBalancer loadBalancer) {
865 LoadBalanceDefinition answer = new LoadBalanceDefinition();
866 addOutput(answer);
867 return answer.loadBalance(loadBalancer);
868 }
869
870 /**
871 * <a href="http://camel.apache.org/content-based-router.html">Content Based Router EIP:</a>
872 * Creates a choice of one or more predicates with an otherwise clause
873 *
874 * @return the builder for a choice expression
875 */
876 public ChoiceDefinition choice() {
877 ChoiceDefinition answer = new ChoiceDefinition();
878 addOutput(answer);
879 return answer;
880 }
881
882 /**
883 * Creates a try/catch block
884 *
885 * @return the builder for a tryBlock expression
886 */
887 public TryDefinition doTry() {
888 TryDefinition answer = new TryDefinition();
889 addOutput(answer);
890 return answer;
891 }
892
893 /**
894 * <a href="http://camel.apache.org/recipient-list.html">Recipient List EIP:</a>
895 * Creates a dynamic recipient list allowing you to route messages to a number of dynamically specified recipients
896 *
897 * @param recipients expression to decide the destinations
898 * @return the builder
899 */
900 @SuppressWarnings("unchecked")
901 public Type recipientList(Expression recipients) {
902 RecipientListDefinition answer = new RecipientListDefinition(recipients);
903 addOutput(answer);
904 return (Type) this;
905 }
906
907 /**
908 * <a href="http://camel.apache.org/recipient-list.html">Recipient List EIP:</a>
909 * Creates a dynamic recipient list allowing you to route messages to a number of dynamically specified recipients
910 *
911 * @return the expression clause to configure the expression to decide the destinations
912 */
913 public ExpressionClause<ProcessorDefinition<Type>> recipientList() {
914 RecipientListDefinition answer = new RecipientListDefinition();
915 addOutput(answer);
916 ExpressionClause<ProcessorDefinition<Type>> clause = new ExpressionClause<ProcessorDefinition<Type>>(this);
917 answer.setExpression(clause);
918 return clause;
919 }
920
921 /**
922 * <a href="http://camel.apache.org/routing-slip.html">Routing Slip EIP:</a>
923 * Creates a routing slip allowing you to route a message consecutively through a series of processing
924 * steps where the sequence of steps is not known at design time and can vary for each message.
925 *
926 * @param header is the header that the {@link org.apache.camel.processor.RoutingSlip RoutingSlip}
927 * class will look in for the list of URIs to route the message to.
928 * @param uriDelimiter is the delimiter that will be used to split up
929 * the list of URIs in the routing slip.
930 * @return the buiider
931 */
932 @SuppressWarnings("unchecked")
933 public Type routingSlip(String header, String uriDelimiter) {
934 RoutingSlipDefinition answer = new RoutingSlipDefinition(header, uriDelimiter);
935 addOutput(answer);
936 return (Type) this;
937 }
938
939 /**
940 * <a href="http://camel.apache.org/routing-slip.html">Routing Slip EIP:</a>
941 * Creates a routing slip allowing you to route a message consecutively through a series of processing
942 * steps where the sequence of steps is not known at design time and can vary for each message.
943 * <p>
944 * The list of URIs will be split based on the default delimiter {@link RoutingSlipDefinition#DEFAULT_DELIMITER}
945 *
946 * @param header is the header that the {@link org.apache.camel.processor.RoutingSlip RoutingSlip}
947 * class will look in for the list of URIs to route the message to.
948 * @return the builder
949 */
950 @SuppressWarnings("unchecked")
951 public Type routingSlip(String header) {
952 RoutingSlipDefinition answer = new RoutingSlipDefinition(header);
953 addOutput(answer);
954 return (Type) this;
955 }
956
957 /**
958 * <a href="http://camel.apache.org/splitter.html">Splitter EIP:</a>
959 * Creates a splitter allowing you split a message into a number of pieces and process them individually.
960 * <p>
961 * This splitter responds with the latest message returned from destination
962 * endpoint.
963 *
964 * @return the expression clause builder for the expression on which to split
965 */
966 public ExpressionClause<SplitDefinition> split() {
967 SplitDefinition answer = new SplitDefinition();
968 addOutput(answer);
969 return ExpressionClause.createAndSetExpression(answer);
970 }
971
972 /**
973 * <a href="http://camel.apache.org/splitter.html">Splitter EIP:</a>
974 * Creates a splitter allowing you split a message into a number of pieces and process them individually.
975 * <p>
976 * This splitter responds with the latest message returned from destination
977 * endpoint.
978 *
979 * @param expression the expression on which to split the message
980 * @return the builder
981 */
982 public SplitDefinition split(Expression expression) {
983 SplitDefinition answer = new SplitDefinition(expression);
984 addOutput(answer);
985 return answer;
986 }
987
988 /**
989 * <a href="http://camel.apache.org/splitter.html">Splitter EIP:</a>
990 * Creates a splitter allowing you split a message into a number of pieces and process them individually.
991 * <p>
992 * The splitter responds with the answer produced by the given {@link AggregationStrategy}.
993 *
994 * @param expression the expression on which to split
995 * @param aggregationStrategy the strategy used to aggregate responses for every part
996 * @return the builder
997 */
998 public SplitDefinition split(Expression expression, AggregationStrategy aggregationStrategy) {
999 SplitDefinition answer = new SplitDefinition(expression);
1000 addOutput(answer);
1001 answer.setAggregationStrategy(aggregationStrategy);
1002 return answer;
1003 }
1004
1005 /**
1006 * <a href="http://camel.apache.org/resequencer.html">Resequencer EIP:</a>
1007 * Creates a resequencer allowing you to reorganize messages based on some comparator.
1008 *
1009 * @return the expression clause for the expressions on which to compare messages in order
1010 */
1011 public ExpressionClause<ResequenceDefinition> resequence() {
1012 ResequenceDefinition answer = new ResequenceDefinition();
1013 addOutput(answer);
1014 ExpressionClause<ResequenceDefinition> clause = new ExpressionClause<ResequenceDefinition>(answer);
1015 answer.expression(clause);
1016 return clause;
1017 }
1018
1019 /**
1020 * <a href="http://camel.apache.org/resequencer.html">Resequencer EIP:</a>
1021 * Creates a resequencer allowing you to reorganize messages based on some comparator.
1022 *
1023 * @param expression the expression on which to compare messages in order
1024 * @return the builder
1025 */
1026 public ResequenceDefinition resequence(Expression expression) {
1027 return resequence(Collections.<Expression>singletonList(expression));
1028 }
1029
1030 /**
1031 * <a href="http://camel.apache.org/resequencer.html">Resequencer EIP:</a>
1032 * Creates a resequencer allowing you to reorganize messages based on some comparator.
1033 *
1034 * @param expressions the list of expressions on which to compare messages in order
1035 * @return the builder
1036 */
1037 public ResequenceDefinition resequence(List<Expression> expressions) {
1038 ResequenceDefinition answer = new ResequenceDefinition(expressions);
1039 addOutput(answer);
1040 return answer;
1041 }
1042
1043 /**
1044 * <a href="http://camel.apache.org/resequencer.html">Resequencer EIP:</a>
1045 * Creates a splitter allowing you to reorganise messages based on some comparator.
1046 *
1047 * @param expressions the list of expressions on which to compare messages in order
1048 * @return the builder
1049 */
1050 public ResequenceDefinition resequencer(Expression... expressions) {
1051 List<Expression> list = new ArrayList<Expression>();
1052 list.addAll(Arrays.asList(expressions));
1053 return resequence(list);
1054 }
1055
1056 /**
1057 * <a href="http://camel.apache.org/aggregator.html">Aggregator EIP:</a>
1058 * Creates an aggregator allowing you to combine a number of messages together into a single message.
1059 *
1060 * @return the expression clause to be used as builder to configure the correlation expression
1061 */
1062 public ExpressionClause<AggregateDefinition> aggregate() {
1063 AggregateDefinition answer = new AggregateDefinition();
1064 addOutput(answer);
1065 return answer.createAndSetExpression();
1066 }
1067
1068 /**
1069 * <a href="http://camel.apache.org/aggregator.html">Aggregator EIP:</a>
1070 * Creates an aggregator allowing you to combine a number of messages together into a single message.
1071 *
1072 * @param aggregationStrategy the strategy used for the aggregation
1073 * @return the expression clause to be used as builder to configure the correlation expression
1074 */
1075 public ExpressionClause<AggregateDefinition> aggregate(AggregationStrategy aggregationStrategy) {
1076 AggregateDefinition answer = new AggregateDefinition();
1077 answer.setAggregationStrategy(aggregationStrategy);
1078 addOutput(answer);
1079 return answer.createAndSetExpression();
1080 }
1081
1082 /**
1083 * <a href="http://camel.apache.org/aggregator.html">Aggregator EIP:</a>
1084 * Creates an aggregator allowing you to combine a number of messages together into a single message.
1085 *
1086 * @param aggregationCollection the collection used to perform the aggregation
1087 * @return the builder
1088 */
1089 public AggregateDefinition aggregate(AggregationCollection aggregationCollection) {
1090 AggregateDefinition answer = new AggregateDefinition();
1091 answer.setAggregationCollection(aggregationCollection);
1092 addOutput(answer);
1093 return answer;
1094 }
1095
1096 /**
1097 * <a href="http://camel.apache.org/aggregator.html">Aggregator EIP:</a>
1098 * Creates an aggregator allowing you to combine a number of messages together into a single message.
1099 *
1100 * @param correlationExpression the expression used to calculate the
1101 * correlation key. For a JMS message this could be the
1102 * expression <code>header("JMSDestination")</code> or
1103 * <code>header("JMSCorrelationID")</code>
1104 * @return the builder
1105 */
1106 public AggregateDefinition aggregate(Expression correlationExpression) {
1107 AggregateDefinition answer = new AggregateDefinition(correlationExpression);
1108 addOutput(answer);
1109 return answer;
1110 }
1111
1112 /**
1113 * <a href="http://camel.apache.org/aggregator.html">Aggregator EIP:</a>
1114 * Creates an aggregator allowing you to combine a number of messages together into a single message.
1115 *
1116 * @param correlationExpression the expression used to calculate the
1117 * correlation key. For a JMS message this could be the
1118 * expression <code>header("JMSDestination")</code> or
1119 * <code>header("JMSCorrelationID")</code>
1120 * @param aggregationStrategy the strategy used for the aggregation
1121 * @return the builder
1122 */
1123 public AggregateDefinition aggregate(Expression correlationExpression, AggregationStrategy aggregationStrategy) {
1124 AggregateDefinition answer = new AggregateDefinition(correlationExpression, aggregationStrategy);
1125 addOutput(answer);
1126 return answer;
1127 }
1128
1129 /**
1130 * <a href="http://camel.apache.org/delayer.html">Delayer EIP:</a>
1131 * Creates a delayer allowing you to delay the delivery of messages to some destination.
1132 *
1133 * @param delay an expression to calculate the delay time in millis
1134 * @return the builder
1135 */
1136 public DelayDefinition delay(Expression delay) {
1137 DelayDefinition answer = new DelayDefinition(delay);
1138 addOutput(answer);
1139 return answer;
1140 }
1141
1142 /**
1143 * <a href="http://camel.apache.org/delayer.html">Delayer EIP:</a>
1144 * Creates a delayer allowing you to delay the delivery of messages to some destination.
1145 *
1146 * @return the expression clause to create the expression
1147 */
1148 public ExpressionClause<DelayDefinition> delay() {
1149 DelayDefinition answer = new DelayDefinition();
1150 addOutput(answer);
1151 return ExpressionClause.createAndSetExpression(answer);
1152 }
1153
1154 /**
1155 * <a href="http://camel.apache.org/delayer.html">Delayer EIP:</a>
1156 * Creates a delayer allowing you to delay the delivery of messages to some destination.
1157 *
1158 * @param delay the delay in millis
1159 * @return the builder
1160 */
1161 public DelayDefinition delay(long delay) {
1162 return delay(ExpressionBuilder.constantExpression(delay));
1163 }
1164
1165 /**
1166 * <a href="http://camel.apache.org/throttler.html">Throttler EIP:</a>
1167 * Creates a throttler allowing you to ensure that a specific endpoint does not get overloaded,
1168 * or that we don't exceed an agreed SLA with some external service.
1169 * <p/>
1170 * Will default use a time period of 1 second, so setting the maximumRequestCount to eg 10
1171 * will default ensure at most 10 messages per second.
1172 *
1173 * @param maximumRequestCount the maximum messages
1174 * @return the builder
1175 */
1176 public ThrottleDefinition throttle(long maximumRequestCount) {
1177 ThrottleDefinition answer = new ThrottleDefinition(maximumRequestCount);
1178 addOutput(answer);
1179 return answer;
1180 }
1181
1182 /**
1183 * <a href="http://camel.apache.org/loop.html">Loop EIP:</a>
1184 * Creates a loop allowing to process the a message a number of times and possibly process them
1185 * in a different way. Useful mostly for testing.
1186 *
1187 * @return the clause used to create the loop expression
1188 */
1189 public ExpressionClause<LoopDefinition> loop() {
1190 LoopDefinition loop = new LoopDefinition();
1191 addOutput(loop);
1192 return ExpressionClause.createAndSetExpression(loop);
1193 }
1194
1195 /**
1196 * <a href="http://camel.apache.org/loop.html">Loop EIP:</a>
1197 * Creates a loop allowing to process the a message a number of times and possibly process them
1198 * in a different way. Useful mostly for testing.
1199 *
1200 * @param expression the loop expression
1201 * @return the builder
1202 */
1203 public LoopDefinition loop(Expression expression) {
1204 LoopDefinition loop = getNodeFactory().createLoop();
1205 loop.setExpression(expression);
1206 addOutput(loop);
1207 return loop;
1208 }
1209
1210 /**
1211 * <a href="http://camel.apache.org/loop.html">Loop EIP:</a>
1212 * Creates a loop allowing to process the a message a number of times and possibly process them
1213 * in a different way. Useful mostly for testing.
1214 *
1215 * @param count the number of times
1216 * @return the builder
1217 */
1218 public LoopDefinition loop(int count) {
1219 LoopDefinition loop = getNodeFactory().createLoop();
1220 loop.setExpression(new ConstantExpression(Integer.toString(count)));
1221 addOutput(loop);
1222 return loop;
1223 }
1224
1225 /**
1226 * Sets the exception on the {@link org.apache.camel.Exchange}
1227 *
1228 * @param exception the exception to throw
1229 * @return the builder
1230 */
1231 @SuppressWarnings("unchecked")
1232 public Type throwException(Exception exception) {
1233 ThrowExceptionDefinition answer = new ThrowExceptionDefinition();
1234 answer.setException(exception);
1235 addOutput(answer);
1236 return (Type) this;
1237 }
1238
1239 /**
1240 * Marks the exchange for rollback only.
1241 * <p/>
1242 * This is done by setting a {@link org.apache.camel.RollbackExchangeException} on the Exchange
1243 * and mark it for rollback.
1244 *
1245 * @return the builder
1246 */
1247 @SuppressWarnings("unchecked")
1248 public Type rollback() {
1249 return rollback(null);
1250 }
1251
1252 /**
1253 * Marks the exchange for rollback only.
1254 * <p/>
1255 * This is done by setting a {@link org.apache.camel.RollbackExchangeException} on the Exchange
1256 * and mark it for rollback.
1257 *
1258 * @param message an optional message used for logging purpose why the rollback was triggered
1259 * @return the builder
1260 */
1261 @SuppressWarnings("unchecked")
1262 public Type rollback(String message) {
1263 RollbackDefinition answer = new RollbackDefinition(message);
1264 addOutput(answer);
1265 return (Type) this;
1266 }
1267
1268 /**
1269 * <a href="http://camel.apache.org/wiretap.html">WireTap EIP:</a>
1270 * Sends messages to all its child outputs; so that each processor and
1271 * destination gets a copy of the original message to avoid the processors
1272 * interfering with each other using {@link ExchangePattern#InOnly}.
1273 *
1274 * @return the builder
1275 */
1276 @SuppressWarnings("unchecked")
1277 public Type wireTap(String uri) {
1278 WireTapDefinition answer = new WireTapDefinition();
1279 answer.setUri(uri);
1280 addOutput(answer);
1281 return (Type) this;
1282 }
1283
1284 /**
1285 * <a href="http://camel.apache.org/wiretap.html">WireTap EIP:</a>
1286 * Sends a new {@link org.apache.camel.Exchange} to the destination
1287 * using {@link ExchangePattern#InOnly}.
1288 *
1289 * @param uri the destination
1290 * @param body expression that creates the body to send
1291 * @return the builder
1292 */
1293 @SuppressWarnings("unchecked")
1294 public Type wireTap(String uri, Expression body) {
1295 WireTapDefinition answer = new WireTapDefinition();
1296 answer.setUri(uri);
1297 answer.setNewExchangeExpression(body);
1298 addOutput(answer);
1299 return (Type) this;
1300 }
1301
1302 /**
1303 * <a href="http://camel.apache.org/wiretap.html">WireTap EIP:</a>
1304 * Sends a new {@link org.apache.camel.Exchange} to the destination
1305 * using {@link ExchangePattern#InOnly}.
1306 *
1307 * @param uri the destination
1308 * @param processor processor preparing the new exchange to send
1309 * @return the builder
1310 */
1311 @SuppressWarnings("unchecked")
1312 public Type wireTap(String uri, Processor processor) {
1313 WireTapDefinition answer = new WireTapDefinition();
1314 answer.setUri(uri);
1315 answer.setNewExchangeProcessor(processor);
1316 addOutput(answer);
1317 return (Type) this;
1318 }
1319
1320 /**
1321 * Pushes the given block on the stack as current block
1322 * @param block the block
1323 */
1324 void pushBlock(Block block) {
1325 blocks.add(block);
1326 }
1327
1328 /**
1329 * Pops the block off the stack as current block
1330 * @return the block
1331 */
1332 Block popBlock() {
1333 return blocks.isEmpty() ? null : blocks.removeLast();
1334 }
1335
1336 /**
1337 * Stops continue routing the current {@link org.apache.camel.Exchange} and marks it as completed.
1338 *
1339 * @return the builder
1340 */
1341 @SuppressWarnings("unchecked")
1342 public Type stop() {
1343 StopDefinition stop = new StopDefinition();
1344 addOutput(stop);
1345 return (Type) this;
1346 }
1347
1348 /**
1349 * <a href="http://camel.apache.org/exception-clause.html">Exception clause</a>
1350 * for cathing certain exceptions and handling them.
1351 *
1352 * @param exceptionType the exception to catch
1353 * @return the exception builder to configure
1354 */
1355 public OnExceptionDefinition onException(Class exceptionType) {
1356 OnExceptionDefinition answer = new OnExceptionDefinition(exceptionType);
1357 addOutput(answer);
1358 return answer;
1359 }
1360
1361 /**
1362 * Apply a {@link Policy}.
1363 * <p/>
1364 * Policy can be used for transactional policies.
1365 *
1366 * @param policy the policy to apply
1367 * @return the policy builder to configure
1368 */
1369 public PolicyDefinition policy(Policy policy) {
1370 PolicyDefinition answer = new PolicyDefinition(policy);
1371 addOutput(answer);
1372 return answer;
1373 }
1374
1375 /**
1376 * Apply a {@link Policy}.
1377 * <p/>
1378 * Policy can be used for transactional policies.
1379 *
1380 * @param ref reference to lookup a policy in the registry
1381 * @return the policy builder to configure
1382 */
1383 public PolicyDefinition policy(String ref) {
1384 PolicyDefinition answer = new PolicyDefinition();
1385 answer.setRef(ref);
1386 addOutput(answer);
1387 return answer;
1388 }
1389
1390 /**
1391 * Marks this route as transacted and uses the default transacted policy found in the registry.
1392 *
1393 * @return the policy builder to configure
1394 */
1395 public PolicyDefinition transacted() {
1396 PolicyDefinition answer = new PolicyDefinition();
1397 answer.setType(TransactedPolicy.class);
1398 addOutput(answer);
1399 return answer;
1400 }
1401
1402 /**
1403 * Marks this route as transacted.
1404 *
1405 * @param ref reference to lookup a transacted policy in the registry
1406 * @return the policy builder to configure
1407 */
1408 public PolicyDefinition transacted(String ref) {
1409 PolicyDefinition answer = new PolicyDefinition();
1410 answer.setType(TransactedPolicy.class);
1411 answer.setRef(ref);
1412 addOutput(answer);
1413 return answer;
1414 }
1415
1416 /**
1417 * Installs the given <a href="http://camel.apache.org/error-handler.html">error handler</a> builder.
1418 *
1419 * @param errorHandlerBuilder the error handler to be used by default for all child routes
1420 * @return the current builder with the error handler configured
1421 */
1422 @SuppressWarnings("unchecked")
1423 public Type errorHandler(ErrorHandlerBuilder errorHandlerBuilder) {
1424 setErrorHandlerBuilder(errorHandlerBuilder);
1425 return (Type) this;
1426 }
1427
1428 // Transformers
1429 // -------------------------------------------------------------------------
1430
1431 /**
1432 * <a href="http://camel.apache.org/message-translator.html">Message Translator EIP:</a>
1433 * Adds the custom processor to this destination which could be a final
1434 * destination, or could be a transformation in a pipeline
1435 *
1436 * @param processor the custom {@link Processor}
1437 * @return the builder
1438 */
1439 @SuppressWarnings("unchecked")
1440 public Type process(Processor processor) {
1441 ProcessDefinition answer = new ProcessDefinition(processor);
1442 addOutput(answer);
1443 return (Type) this;
1444 }
1445
1446 /**
1447 * <a href="http://camel.apache.org/message-translator.html">Message Translator EIP:</a>
1448 * Adds the custom processor reference to this destination which could be a final
1449 * destination, or could be a transformation in a pipeline
1450 *
1451 * @param ref reference to a {@link Processor} to lookup in the registry
1452 * @return the builder
1453 */
1454 @SuppressWarnings("unchecked")
1455 public Type processRef(String ref) {
1456 ProcessDefinition answer = new ProcessDefinition();
1457 answer.setRef(ref);
1458 addOutput(answer);
1459 return (Type) this;
1460 }
1461
1462 /**
1463 * <a href="http://camel.apache.org/message-translator.html">Message Translator EIP:</a>
1464 * Adds a bean which is invoked which could be a final destination, or could be a transformation in a pipeline
1465 *
1466 * @param bean the bean to invoke
1467 * @return the builder
1468 */
1469 @SuppressWarnings("unchecked")
1470 public Type bean(Object bean) {
1471 BeanDefinition answer = new BeanDefinition();
1472 answer.setBean(bean);
1473 addOutput(answer);
1474 return (Type) this;
1475 }
1476
1477 /**
1478 * <a href="http://camel.apache.org/message-translator.html">Message Translator EIP:</a>
1479 * Adds a bean which is invoked which could be a final destination, or could be a transformation in a pipeline
1480 *
1481 * @param bean the bean to invoke
1482 * @param method the method name to invoke on the bean (can be used to avoid ambiguty)
1483 * @return the builder
1484 */
1485 @SuppressWarnings("unchecked")
1486 public Type bean(Object bean, String method) {
1487 BeanDefinition answer = new BeanDefinition();
1488 answer.setBean(bean);
1489 answer.setMethod(method);
1490 addOutput(answer);
1491 return (Type) this;
1492 }
1493
1494 /**
1495 * <a href="http://camel.apache.org/message-translator.html">Message Translator EIP:</a>
1496 * Adds a bean which is invoked which could be a final destination, or could be a transformation in a pipeline
1497 *
1498 * @param beanType the bean class, Camel will instantiate an object at runtime
1499 * @return the builder
1500 */
1501 @SuppressWarnings("unchecked")
1502 public Type bean(Class beanType) {
1503 BeanDefinition answer = new BeanDefinition();
1504 answer.setBeanType(beanType);
1505 addOutput(answer);
1506 return (Type) this;
1507 }
1508
1509 /**
1510 * <a href="http://camel.apache.org/message-translator.html">Message Translator EIP:</a>
1511 * Adds a bean which is invoked which could be a final destination, or could be a transformation in a pipeline
1512 *
1513 * @param beanType the bean class, Camel will instantiate an object at runtime
1514 * @param method the method name to invoke on the bean (can be used to avoid ambiguty)
1515 * @return the builder
1516 */
1517 @SuppressWarnings("unchecked")
1518 public Type bean(Class beanType, String method) {
1519 BeanDefinition answer = new BeanDefinition();
1520 answer.setBeanType(beanType);
1521 answer.setMethod(method);
1522 addOutput(answer);
1523 return (Type) this;
1524 }
1525
1526 /**
1527 * <a href="http://camel.apache.org/message-translator.html">Message Translator EIP:</a>
1528 * Adds a bean which is invoked which could be a final destination, or could be a transformation in a pipeline
1529 *
1530 * @param ref reference to a bean to lookup in the registry
1531 * @return the builder
1532 */
1533 @SuppressWarnings("unchecked")
1534 public Type beanRef(String ref) {
1535 BeanDefinition answer = new BeanDefinition(ref);
1536 addOutput(answer);
1537 return (Type) this;
1538 }
1539
1540 /**
1541 * <a href="http://camel.apache.org/message-translator.html">Message Translator EIP:</a>
1542 * Adds a bean which is invoked which could be a final destination, or could be a transformation in a pipeline
1543 *
1544 * @param ref reference to a bean to lookup in the registry
1545 * @param method the method name to invoke on the bean (can be used to avoid ambiguty)
1546 * @return the builder
1547 */
1548 @SuppressWarnings("unchecked")
1549 public Type beanRef(String ref, String method) {
1550 BeanDefinition answer = new BeanDefinition(ref, method);
1551 addOutput(answer);
1552 return (Type) this;
1553 }
1554
1555 /**
1556 * <a href="http://camel.apache.org/message-translator.html">Message Translator EIP:</a>
1557 * Adds a processor which sets the body on the IN message
1558 *
1559 * @return a expression builder clause to set the body
1560 */
1561 public ExpressionClause<ProcessorDefinition<Type>> setBody() {
1562 ExpressionClause<ProcessorDefinition<Type>> clause = new ExpressionClause<ProcessorDefinition<Type>>(this);
1563 SetBodyDefinition answer = new SetBodyDefinition(clause);
1564 addOutput(answer);
1565 return clause;
1566 }
1567
1568 /**
1569 * <a href="http://camel.apache.org/message-translator.html">Message Translator EIP:</a>
1570 * Adds a processor which sets the body on the IN message
1571 *
1572 * @param expression the expression used to set the body
1573 * @return the builder
1574 */
1575 @SuppressWarnings("unchecked")
1576 public Type setBody(Expression expression) {
1577 SetBodyDefinition answer = new SetBodyDefinition(expression);
1578 addOutput(answer);
1579 return (Type) this;
1580 }
1581
1582 /**
1583 * <a href="http://camel.apache.org/message-translator.html">Message Translator EIP:</a>
1584 * Adds a processor which sets the body on the OUT message
1585 *
1586 * @param expression the expression used to set the body
1587 * @return the builder
1588 */
1589 @SuppressWarnings("unchecked")
1590 public Type transform(Expression expression) {
1591 TransformDefinition answer = new TransformDefinition(expression);
1592 addOutput(answer);
1593 return (Type) this;
1594 }
1595
1596 /**
1597 * <a href="http://camel.apache.org/message-translator.html">Message Translator EIP:</a>
1598 * Adds a processor which sets the body on the OUT message
1599 *
1600 * @return a expression builder clause to set the body
1601 */
1602 public ExpressionClause<ProcessorDefinition<Type>> transform() {
1603 ExpressionClause<ProcessorDefinition<Type>> clause = new ExpressionClause<ProcessorDefinition<Type>>((Type) this);
1604 TransformDefinition answer = new TransformDefinition(clause);
1605 addOutput(answer);
1606 return clause;
1607 }
1608
1609 /**
1610 * Adds a processor which sets the body on the FAULT message
1611 *
1612 * @param expression the expression used to set the body
1613 * @return the builder
1614 */
1615 public Type setFaultBody(Expression expression) {
1616 return process(ProcessorBuilder.setFaultBody(expression));
1617 }
1618
1619 /**
1620 * Adds a processor which sets the header on the IN message
1621 *
1622 * @param name the header name
1623 * @return a expression builder clause to set the header
1624 */
1625 public ExpressionClause<ProcessorDefinition<Type>> setHeader(String name) {
1626 ExpressionClause<ProcessorDefinition<Type>> clause = new ExpressionClause<ProcessorDefinition<Type>>(this);
1627 SetHeaderDefinition answer = new SetHeaderDefinition(name, clause);
1628 addOutput(answer);
1629 return clause;
1630 }
1631
1632 /**
1633 * Adds a processor which sets the header on the IN message
1634 *
1635 * @param name the header name
1636 * @param expression the expression used to set the header
1637 * @return the builder
1638 */
1639 @SuppressWarnings("unchecked")
1640 public Type setHeader(String name, Expression expression) {
1641 SetHeaderDefinition answer = new SetHeaderDefinition(name, expression);
1642 addOutput(answer);
1643 return (Type) this;
1644 }
1645
1646 /**
1647 * Adds a processor which sets the header on the OUT message
1648 *
1649 * @param name the header name
1650 * @return a expression builder clause to set the header
1651 */
1652 public ExpressionClause<ProcessorDefinition<Type>> setOutHeader(String name) {
1653 ExpressionClause<ProcessorDefinition<Type>> clause = new ExpressionClause<ProcessorDefinition<Type>>(this);
1654 SetOutHeaderDefinition answer = new SetOutHeaderDefinition(name, clause);
1655 addOutput(answer);
1656 return clause;
1657 }
1658
1659 /**
1660 * Adds a processor which sets the header on the OUT message
1661 *
1662 * @param name the header name
1663 * @param expression the expression used to set the header
1664 * @return the builder
1665 */
1666 @SuppressWarnings("unchecked")
1667 public Type setOutHeader(String name, Expression expression) {
1668 SetOutHeaderDefinition answer = new SetOutHeaderDefinition(name, expression);
1669 addOutput(answer);
1670 return (Type) this;
1671 }
1672
1673 /**
1674 * Adds a processor which sets the header on the FAULT message
1675 *
1676 * @param name the header name
1677 * @param expression the expression used to set the header
1678 * @return the builder
1679 */
1680 public Type setFaultHeader(String name, Expression expression) {
1681 return process(ProcessorBuilder.setFaultHeader(name, expression));
1682 }
1683
1684 /**
1685 * Adds a processor which sets the exchange property
1686 *
1687 * @param name the property name
1688 * @param expression the expression used to set the property
1689 * @return the builder
1690 */
1691 @SuppressWarnings("unchecked")
1692 public Type setProperty(String name, Expression expression) {
1693 SetPropertyDefinition answer = new SetPropertyDefinition(name, expression);
1694 addOutput(answer);
1695 return (Type) this;
1696 }
1697
1698
1699 /**
1700 * Adds a processor which sets the exchange property
1701 *
1702 * @param name the property name
1703 * @return a expression builder clause to set the property
1704 */
1705 public ExpressionClause<ProcessorDefinition<Type>> setProperty(String name) {
1706 ExpressionClause<ProcessorDefinition<Type>> clause = new ExpressionClause<ProcessorDefinition<Type>>(this);
1707 SetPropertyDefinition answer = new SetPropertyDefinition(name, clause);
1708 addOutput(answer);
1709 return clause;
1710 }
1711
1712 /**
1713 * Adds a processor which removes the header on the IN message
1714 *
1715 * @param name the header name
1716 * @return the builder
1717 */
1718 @SuppressWarnings("unchecked")
1719 public Type removeHeader(String name) {
1720 RemoveHeaderDefinition answer = new RemoveHeaderDefinition(name);
1721 addOutput(answer);
1722 return (Type) this;
1723 }
1724
1725 /**
1726 * Adds a processor which removes the header on the FAULT message
1727 *
1728 * @param name the header name
1729 * @return the builder
1730 */
1731 public Type removeFaultHeader(String name) {
1732 return process(ProcessorBuilder.removeFaultHeader(name));
1733 }
1734
1735 /**
1736 * Adds a processor which removes the exchange property
1737 *
1738 * @param name the property name
1739 * @return the builder
1740 */
1741 @SuppressWarnings("unchecked")
1742 public Type removeProperty(String name) {
1743 RemovePropertyDefinition answer = new RemovePropertyDefinition(name);
1744 addOutput(answer);
1745 return (Type) this;
1746 }
1747
1748 /**
1749 * Converts the IN message body to the specified type
1750 *
1751 * @param type the type to convert to
1752 * @return the builder
1753 */
1754 @SuppressWarnings("unchecked")
1755 public Type convertBodyTo(Class type) {
1756 addOutput(new ConvertBodyDefinition(type));
1757 return (Type) this;
1758 }
1759
1760 /**
1761 * Converts the IN message body to the specified type
1762 *
1763 * @param type the type to convert to
1764 * @param charset the charset to use by type converters (not all converters support specifc charset)
1765 * @return the builder
1766 */
1767 @SuppressWarnings("unchecked")
1768 public Type convertBodyTo(Class type, String charset) {
1769 addOutput(new ConvertBodyDefinition(type, charset));
1770 return (Type) this;
1771 }
1772
1773 /**
1774 * Sorts the IN message body using the given comparator.
1775 * The IN body mut be convertable to {@link List}.
1776 *
1777 * @param comparator the comparator to use for sorting
1778 * @return the builder
1779 */
1780 @SuppressWarnings("unchecked")
1781 public Type sortBody(Comparator comparator) {
1782 addOutput(new SortDefinition(body(), comparator));
1783 return (Type) this;
1784 }
1785
1786 /**
1787 * Sorts the IN message body using a default sorting based on toString representation.
1788 * The IN body mut be convertable to {@link List}.
1789 *
1790 * @return the builder
1791 */
1792 public Type sortBody() {
1793 return sortBody(null);
1794 }
1795
1796 /**
1797 * Sorts the expression using the given comparator
1798 *
1799 * @param expression the expression, must be convertable to {@link List}
1800 * @param comparator the comparator to use for sorting
1801 * @return the builder
1802 */
1803 @SuppressWarnings("unchecked")
1804 public Type sort(Expression expression, Comparator comparator) {
1805 addOutput(new SortDefinition(expression, comparator));
1806 return (Type) this;
1807 }
1808
1809 /**
1810 * Sorts the expression using a default sorting based on toString representation.
1811 *
1812 * @param expression the expression, must be convertable to {@link List}
1813 * @return the builder
1814 */
1815 public Type sort(Expression expression) {
1816 return sort(expression, null);
1817 }
1818
1819 /**
1820 * The <a href="http://camel.apache.org/content-enricher.html">Content Enricher EIP</a>
1821 * enriches an exchange with additional data obtained from a <code>resourceUri</code>.
1822 *
1823 * @param resourceUri URI of resource endpoint for obtaining additional data.
1824 * @param aggregationStrategy aggregation strategy to aggregate input data and additional data.
1825 * @return the builder
1826 * @see org.apache.camel.processor.Enricher
1827 */
1828 @SuppressWarnings("unchecked")
1829 public Type enrich(String resourceUri, AggregationStrategy aggregationStrategy) {
1830 addOutput(new EnrichDefinition(aggregationStrategy, resourceUri));
1831 return (Type) this;
1832 }
1833
1834 /**
1835 * The <a href="http://camel.apache.org/content-enricher.html">Content Enricher EIP</a>
1836 * enriches an exchange with additional data obtained from a <code>resourceUri</code>.
1837 * <p/>
1838 * The difference between this and {@link #pollEnrich(String)} is that this uses a producer
1839 * to obatin the additional data, where as pollEnrich uses a polling consumer.
1840 *
1841 * @param resourceUri URI of resource endpoint for obtaining additional data.
1842 * @return the builder
1843 * @see org.apache.camel.processor.Enricher
1844 */
1845 @SuppressWarnings("unchecked")
1846 public Type enrich(String resourceUri) {
1847 addOutput(new EnrichDefinition(resourceUri));
1848 return (Type) this;
1849 }
1850
1851 /**
1852 * The <a href="http://camel.apache.org/content-enricher.html">Content Enricher EIP</a>
1853 * enriches an exchange with additional data obtained from a <code>resourceUri</code>
1854 * using a {@link org.apache.camel.PollingConsumer} to poll the endpoint.
1855 * <p/>
1856 * The difference between this and {@link #enrich(String)} is that this uses a consumer
1857 * to obatin the additional data, where as enrich uses a producer.
1858 * <p/>
1859 * This method will block until data is avialable, use the method with timeout if you do not
1860 * want to risk waiting a long time before data is available from the resourceUri.
1861 *
1862 * @param resourceUri URI of resource endpoint for obtaining additional data.
1863 * @return the builder
1864 * @see org.apache.camel.processor.PollEnricher
1865 */
1866 @SuppressWarnings("unchecked")
1867 public Type pollEnrich(String resourceUri) {
1868 addOutput(new PollEnrichDefinition(null, resourceUri, 0));
1869 return (Type) this;
1870 }
1871
1872 /**
1873 * The <a href="http://camel.apache.org/content-enricher.html">Content Enricher EIP</a>
1874 * enriches an exchange with additional data obtained from a <code>resourceUri</code>
1875 * using a {@link org.apache.camel.PollingConsumer} to poll the endpoint.
1876 * <p/>
1877 * The difference between this and {@link #enrich(String)} is that this uses a consumer
1878 * to obatin the additional data, where as enrich uses a producer.
1879 * <p/>
1880 * This method will block until data is avialable, use the method with timeout if you do not
1881 * want to risk waiting a long time before data is available from the resourceUri.
1882 *
1883 * @param resourceUri URI of resource endpoint for obtaining additional data.
1884 * @param aggregationStrategy aggregation strategy to aggregate input data and additional data.
1885 * @return the builder
1886 * @see org.apache.camel.processor.PollEnricher
1887 */
1888 @SuppressWarnings("unchecked")
1889 public Type pollEnrich(String resourceUri, AggregationStrategy aggregationStrategy) {
1890 addOutput(new PollEnrichDefinition(aggregationStrategy, resourceUri, 0));
1891 return (Type) this;
1892 }
1893
1894 /**
1895 * The <a href="http://camel.apache.org/content-enricher.html">Content Enricher EIP</a>
1896 * enriches an exchange with additional data obtained from a <code>resourceUri</code>
1897 * using a {@link org.apache.camel.PollingConsumer} to poll the endpoint.
1898 * <p/>
1899 * The difference between this and {@link #enrich(String)} is that this uses a consumer
1900 * to obatin the additional data, where as enrich uses a producer.
1901 * <p/>
1902 * The timeout controls which operation to use on {@link org.apache.camel.PollingConsumer}.
1903 * If timeout is negative, we use <tt>receive</tt>. If timeout is 0 then we use <tt>receiveNoWait</tt>
1904 * otherwise we use <tt>receive(timeout)</tt>.
1905 *
1906 * @param resourceUri URI of resource endpoint for obtaining additional data.
1907 * @param timeout timeout in millis to wait at most for data to be available.
1908 * @param aggregationStrategy aggregation strategy to aggregate input data and additional data.
1909 * @return the builder
1910 * @see org.apache.camel.processor.PollEnricher
1911 */
1912 @SuppressWarnings("unchecked")
1913 public Type pollEnrich(String resourceUri, long timeout, AggregationStrategy aggregationStrategy) {
1914 addOutput(new PollEnrichDefinition(aggregationStrategy, resourceUri, timeout));
1915 return (Type) this;
1916 }
1917
1918 /**
1919 * The <a href="http://camel.apache.org/content-enricher.html">Content Enricher EIP</a>
1920 * enriches an exchange with additional data obtained from a <code>resourceUri</code>
1921 * using a {@link org.apache.camel.PollingConsumer} to poll the endpoint.
1922 * <p/>
1923 * The difference between this and {@link #enrich(String)} is that this uses a consumer
1924 * to obatin the additional data, where as enrich uses a producer.
1925 * <p/>
1926 * The timeout controls which operation to use on {@link org.apache.camel.PollingConsumer}.
1927 * If timeout is negative, we use <tt>receive</tt>. If timeout is 0 then we use <tt>receiveNoWait</tt>
1928 * otherwise we use <tt>receive(timeout)</tt>.
1929 *
1930 * @param resourceUri URI of resource endpoint for obtaining additional data.
1931 * @param timeout timeout in millis to wait at most for data to be available.
1932 * @return the builder
1933 * @see org.apache.camel.processor.PollEnricher
1934 */
1935 @SuppressWarnings("unchecked")
1936 public Type pollEnrich(String resourceUri, long timeout) {
1937 addOutput(new PollEnrichDefinition(null, resourceUri, timeout));
1938 return (Type) this;
1939 }
1940
1941 /**
1942 * Adds a onComplection {@link org.apache.camel.spi.Synchronization} hook that invoke this route as
1943 * a callback when the {@link org.apache.camel.Exchange} has finished being processed.
1944 * The hook invoke callbacks for either onComplete or onFailure.
1945 * <p/>
1946 * Will by default always trigger when the {@link org.apache.camel.Exchange} is complete
1947 * (either with success or failed).
1948 * <br/>
1949 * You can limit the callback to either onComplete or onFailure but invoking the nested
1950 * builder method.
1951 * <p/>
1952 * For onFailure the caused exception is stored as a property on the {@link org.apache.camel.Exchange}
1953 * with the key {@link org.apache.camel.Exchange#EXCEPTION_CAUGHT}.
1954 *
1955 * @return the builder
1956 */
1957 @SuppressWarnings("unchecked")
1958 public OnCompletionDefinition onCompletion() {
1959 OnCompletionDefinition answer = new OnCompletionDefinition();
1960 // we must remove all existing on completion definition (as they are global)
1961 // and thus we are the only one as route scoped should override any global scoped
1962 answer.removeAllOnCompletionDefinition(this);
1963 popBlock();
1964 addOutput(answer);
1965 pushBlock(answer);
1966 return answer;
1967 }
1968
1969 // DataFormat support
1970 // -------------------------------------------------------------------------
1971
1972 /**
1973 * <a href="http://camel.apache.org/data-format.html">DataFormat:</a>
1974 * Unmarshals the in body using a {@link DataFormat} expression to define
1975 * the format of the input message and the output will be set on the out message body.
1976 *
1977 * @return the expression to create the {@link DataFormat}
1978 */
1979 public DataFormatClause<ProcessorDefinition<Type>> unmarshal() {
1980 return new DataFormatClause<ProcessorDefinition<Type>>(this, DataFormatClause.Operation.Unmarshal);
1981 }
1982
1983 /**
1984 * <a href="http://camel.apache.org/data-format.html">DataFormat:</a>
1985 * Unmarshals the in body using the specified {@link DataFormat}
1986 * and sets the output on the out message body.
1987 *
1988 * @param dataFormatType the dataformat
1989 * @return the builder
1990 */
1991 @SuppressWarnings("unchecked")
1992 public Type unmarshal(DataFormatDefinition dataFormatType) {
1993 addOutput(new UnmarshalDefinition(dataFormatType));
1994 return (Type) this;
1995 }
1996
1997 /**
1998 * <a href="http://camel.apache.org/data-format.html">DataFormat:</a>
1999 * Unmarshals the in body using the specified {@link DataFormat}
2000 * and sets the output on the out message body.
2001 *
2002 * @param dataFormat the dataformat
2003 * @return the builder
2004 */
2005 public Type unmarshal(DataFormat dataFormat) {
2006 return unmarshal(new DataFormatDefinition(dataFormat));
2007 }
2008
2009 /**
2010 * <a href="http://camel.apache.org/data-format.html">DataFormat:</a>
2011 * Unmarshals the in body using the specified {@link DataFormat}
2012 * reference in the {@link org.apache.camel.spi.Registry} and sets
2013 * the output on the out message body.
2014 *
2015 * @param dataTypeRef reference to a {@link DataFormat} to lookup in the registry
2016 * @return the builder
2017 */
2018 @SuppressWarnings("unchecked")
2019 public Type unmarshal(String dataTypeRef) {
2020 addOutput(new UnmarshalDefinition(dataTypeRef));
2021 return (Type) this;
2022 }
2023
2024 /**
2025 * <a href="http://camel.apache.org/data-format.html">DataFormat:</a>
2026 * Marshals the in body using a {@link DataFormat} expression to define
2027 * the format of the output which will be added to the out body.
2028 *
2029 * @return the expression to create the {@link DataFormat}
2030 */
2031 public DataFormatClause<ProcessorDefinition<Type>> marshal() {
2032 return new DataFormatClause<ProcessorDefinition<Type>>(this, DataFormatClause.Operation.Marshal);
2033 }
2034
2035 /**
2036 * <a href="http://camel.apache.org/data-format.html">DataFormat:</a>
2037 * Marshals the in body using the specified {@link DataFormat}
2038 * and sets the output on the out message body.
2039 *
2040 * @param dataFormatType the dataformat
2041 * @return the builder
2042 */
2043 @SuppressWarnings("unchecked")
2044 public Type marshal(DataFormatDefinition dataFormatType) {
2045 addOutput(new MarshalDefinition(dataFormatType));
2046 return (Type) this;
2047 }
2048
2049 /**
2050 * <a href="http://camel.apache.org/data-format.html">DataFormat:</a>
2051 * Marshals the in body using the specified {@link DataFormat}
2052 * and sets the output on the out message body.
2053 *
2054 * @param dataFormat the dataformat
2055 * @return the builder
2056 */
2057 public Type marshal(DataFormat dataFormat) {
2058 return marshal(new DataFormatDefinition(dataFormat));
2059 }
2060
2061 /**
2062 * <a href="http://camel.apache.org/data-format.html">DataFormat:</a>
2063 * Marshals the in body the specified {@link DataFormat}
2064 * reference in the {@link org.apache.camel.spi.Registry} and sets
2065 * the output on the out message body.
2066 *
2067 * @param dataTypeRef reference to a {@link DataFormat} to lookup in the registry
2068 * @return the builder
2069 */
2070 @SuppressWarnings("unchecked")
2071 public Type marshal(String dataTypeRef) {
2072 addOutput(new MarshalDefinition(dataTypeRef));
2073 return (Type) this;
2074 }
2075
2076 // Properties
2077 // -------------------------------------------------------------------------
2078 @XmlTransient
2079 @SuppressWarnings("unchecked")
2080 public ProcessorDefinition<? extends ProcessorDefinition> getParent() {
2081 return parent;
2082 }
2083
2084 public void setParent(ProcessorDefinition<? extends ProcessorDefinition> parent) {
2085 this.parent = parent;
2086 }
2087
2088 @XmlTransient
2089 public ErrorHandlerBuilder getErrorHandlerBuilder() {
2090 if (errorHandlerBuilder == null) {
2091 errorHandlerBuilder = createErrorHandlerBuilder();
2092 }
2093 return errorHandlerBuilder;
2094 }
2095
2096 /**
2097 * Sets the error handler to use with processors created by this builder
2098 */
2099 public void setErrorHandlerBuilder(ErrorHandlerBuilder errorHandlerBuilder) {
2100 this.errorHandlerBuilder = errorHandlerBuilder;
2101 }
2102
2103 /**
2104 * Sets the error handler if one is not already set
2105 */
2106 protected void setErrorHandlerBuilderIfNull(ErrorHandlerBuilder errorHandlerBuilder) {
2107 if (this.errorHandlerBuilder == null) {
2108 setErrorHandlerBuilder(errorHandlerBuilder);
2109 }
2110 }
2111
2112 public String getErrorHandlerRef() {
2113 return errorHandlerRef;
2114 }
2115
2116 /**
2117 * Sets the bean ref name of the error handler builder to use on this route
2118 */
2119 @XmlAttribute(required = false)
2120 public void setErrorHandlerRef(String errorHandlerRef) {
2121 this.errorHandlerRef = errorHandlerRef;
2122 setErrorHandlerBuilder(new ErrorHandlerBuilderRef(errorHandlerRef));
2123 }
2124
2125 @XmlTransient
2126 public NodeFactory getNodeFactory() {
2127 if (nodeFactory == null) {
2128 nodeFactory = new NodeFactory();
2129 }
2130 return nodeFactory;
2131 }
2132
2133 public void setNodeFactory(NodeFactory nodeFactory) {
2134 this.nodeFactory = nodeFactory;
2135 }
2136
2137 @XmlTransient
2138 public List<InterceptStrategy> getInterceptStrategies() {
2139 return interceptStrategies;
2140 }
2141
2142 public void addInterceptStrategy(InterceptStrategy strategy) {
2143 this.interceptStrategies.add(strategy);
2144 }
2145
2146 /**
2147 * Returns a label to describe this node such as the expression if some kind of expression node
2148 */
2149 public String getLabel() {
2150 return "";
2151 }
2152
2153
2154 }