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 org.apache.camel.processor.CompositeProcessor; 020 import org.apache.camel.Endpoint; 021 import org.apache.camel.Exchange; 022 import org.apache.camel.processor.InterceptorProcessor; 023 import org.apache.camel.Predicate; 024 import org.apache.camel.Processor; 025 026 import java.util.ArrayList; 027 import java.util.List; 028 029 /** 030 * @version $Revision: 520404 $ 031 */ 032 public class DestinationBuilder<E extends Exchange> extends BuilderSupport<E> implements ProcessorBuilder<E> { 033 private RouteBuilder<E> builder; 034 private Endpoint<E> from; 035 private List<Processor<E>> processors = new ArrayList<Processor<E>>(); 036 private List<ProcessorBuilder<E>> processBuilders = new ArrayList<ProcessorBuilder<E>>(); 037 038 public DestinationBuilder(RouteBuilder<E> builder, Endpoint<E> from) { 039 this.builder = builder; 040 this.from = from; 041 } 042 043 public DestinationBuilder(DestinationBuilder<E> parent) { 044 this.builder = parent.getBuilder(); 045 this.from = parent.getFrom(); 046 } 047 048 /** 049 * Resolves the given URI to an endpoint 050 */ 051 public Endpoint<E> endpoint(String uri) { 052 return getBuilder().endpoint(uri); 053 } 054 055 /** 056 * Sends the exchange to the given endpoint URI 057 */ 058 public ProcessorBuilder<E> to(String uri) { 059 return to(endpoint(uri)); 060 } 061 062 /** 063 * Sends the exchange to the given endpoint 064 */ 065 public ProcessorBuilder<E> to(Endpoint<E> endpoint) { 066 ConfiguredDestinationBuilder<E> answer = new ConfiguredDestinationBuilder<E>(this, endpoint); 067 addProcessBuilder(answer); 068 return answer; 069 } 070 071 072 /** 073 * Sends the exchange to the given endpoint URI 074 */ 075 public ProcessorBuilder<E> to(String... uris) { 076 ProcessorBuilder<E> answer = null; 077 for (String uri : uris) { 078 answer = to(endpoint(uri)); 079 } 080 return answer; 081 } 082 083 /** 084 * Sends the exchange to the given endpoint 085 */ 086 public ProcessorBuilder<E> to(Endpoint<E>... endpoints) { 087 ProcessorBuilder<E> answer = null; 088 for (Endpoint<E> endpoint : endpoints) { 089 answer = to(endpoint); 090 } 091 return answer; 092 } 093 094 095 /** 096 * Adds the custom processor to this destination 097 */ 098 public ProcessorBuilder<E> process(Processor<E> processor) { 099 ConstantProcessorBuilder<E> answer = new ConstantProcessorBuilder<E>(processor); 100 addProcessBuilder(answer); 101 return answer; 102 } 103 104 105 106 /** 107 * Creates a predicate which is applied and only if it is true then 108 * the exchange is forwarded to the destination 109 * 110 * @return the builder for a predicate 111 */ 112 public PredicateBuilder<E> filter(Predicate<E> predicate) { 113 PredicateBuilder<E> answer = new PredicateBuilder<E>(this, predicate); 114 addProcessBuilder(answer); 115 return answer; 116 } 117 118 119 /** 120 * Creates a choice of one or more predicates with an otherwise clause 121 * 122 * @return the builder for a choice expression 123 */ 124 public ChoiceBuilder<E> choice() { 125 ChoiceBuilder<E> answer = new ChoiceBuilder<E>(this); 126 addProcessBuilder(answer); 127 return answer; 128 } 129 130 /** 131 * Creates a dynamic <a href="http://activemq.apache.org/camel/recipient-list.html">Recipient List</a> pattern. 132 * 133 * @param valueBuilder 134 */ 135 public RecipientListBuilder<E> recipientList(ValueBuilder<E> valueBuilder) { 136 RecipientListBuilder<E> answer = new RecipientListBuilder<E>(this, valueBuilder); 137 addProcessBuilder(answer); 138 return answer; 139 } 140 141 142 // Properties 143 //------------------------------------------------------------------------- 144 public RouteBuilder<E> getBuilder() { 145 return builder; 146 } 147 148 public Endpoint<E> getFrom() { 149 return from; 150 } 151 152 public void addProcessBuilder(ProcessorBuilder<E> processBuilder) { 153 processBuilders.add(processBuilder); 154 } 155 156 public void addProcessor(Processor<E> processor) { 157 processors.add(processor); 158 } 159 160 public Processor<E> createProcessor() { 161 List<Processor<E>> answer = new ArrayList<Processor<E>>(); 162 163 for (ProcessorBuilder<E> processBuilder : processBuilders) { 164 Processor<E> processor = processBuilder.createProcessor(); 165 if (processor == null) { 166 throw new IllegalArgumentException("No processor created for processBuilder: " + processBuilder); 167 } 168 answer.add(processor); 169 } 170 if (answer.size() == 0) { 171 return null; 172 } 173 if (answer.size() == 1) { 174 return answer.get(0); 175 } 176 else { 177 return new CompositeProcessor<E>(answer); 178 } 179 } 180 181 public List<Processor<E>> getProcessors() { 182 return processors; 183 } 184 185 public InterceptorBuilder<E> intercept() { 186 InterceptorBuilder<E> answer = new InterceptorBuilder<E>(this); 187 addProcessBuilder(answer); 188 return answer; 189 } 190 191 public InterceptorBuilder<E> intercept(InterceptorProcessor<E> interceptor) { 192 InterceptorBuilder<E> answer = new InterceptorBuilder<E>(this); 193 answer.add(interceptor); 194 addProcessBuilder(answer); 195 return answer; 196 } 197 }