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.Collections; 021 import java.util.List; 022 023 import javax.xml.bind.annotation.XmlAccessType; 024 import javax.xml.bind.annotation.XmlAccessorType; 025 import javax.xml.bind.annotation.XmlElement; 026 import javax.xml.bind.annotation.XmlElementRef; 027 import javax.xml.bind.annotation.XmlRootElement; 028 029 import org.apache.camel.Predicate; 030 import org.apache.camel.Processor; 031 import org.apache.camel.builder.ExpressionClause; 032 import org.apache.camel.processor.ChoiceProcessor; 033 import org.apache.camel.processor.FilterProcessor; 034 import org.apache.camel.spi.RouteContext; 035 import org.apache.camel.util.CollectionStringBuffer; 036 037 /** 038 * Represents an XML <choice/> element 039 * 040 * @version $Revision: 784038 $ 041 */ 042 @XmlRootElement(name = "choice") 043 @XmlAccessorType(XmlAccessType.FIELD) 044 public class ChoiceDefinition extends ProcessorDefinition<ChoiceDefinition> { 045 046 @XmlElementRef 047 private List<WhenDefinition> whenClauses = new ArrayList<WhenDefinition>(); 048 @XmlElement(required = false) 049 private OtherwiseDefinition otherwise; 050 051 @Override 052 public String toString() { 053 if (getOtherwise() != null) { 054 return "Choice[" + getWhenClauses() + " " + getOtherwise() + "]"; 055 } else { 056 return "Choice[" + getWhenClauses() + "]"; 057 058 } 059 } 060 @Override 061 public String getShortName() { 062 return "choice"; 063 } 064 065 @Override 066 public Processor createProcessor(RouteContext routeContext) throws Exception { 067 List<FilterProcessor> filters = new ArrayList<FilterProcessor>(); 068 for (WhenDefinition whenClaus : whenClauses) { 069 filters.add(whenClaus.createProcessor(routeContext)); 070 } 071 Processor otherwiseProcessor = null; 072 if (otherwise != null) { 073 otherwiseProcessor = otherwise.createProcessor(routeContext); 074 } 075 return new ChoiceProcessor(filters, otherwiseProcessor); 076 } 077 078 // Fluent API 079 // ------------------------------------------------------------------------- 080 /** 081 * Sets the predicate for the when node 082 * 083 * @param predicate the predicate 084 * @return the builder 085 */ 086 public ChoiceDefinition when(Predicate predicate) { 087 getWhenClauses().add(new WhenDefinition(predicate)); 088 return this; 089 } 090 091 /** 092 * Creates an expression for the when node 093 * 094 * @return expression to be used as builder to configure the when node 095 */ 096 public ExpressionClause<ChoiceDefinition> when() { 097 WhenDefinition when = new WhenDefinition(); 098 getWhenClauses().add(when); 099 ExpressionClause<ChoiceDefinition> clause = new ExpressionClause<ChoiceDefinition>(this); 100 when.setExpression(clause); 101 return clause; 102 } 103 104 /** 105 * Sets the otherwise node 106 * 107 * @return the builder 108 */ 109 public ChoiceDefinition otherwise() { 110 OtherwiseDefinition answer = new OtherwiseDefinition(); 111 setOtherwise(answer); 112 return this; 113 } 114 115 // Properties 116 // ------------------------------------------------------------------------- 117 118 @Override 119 public String getLabel() { 120 CollectionStringBuffer buffer = new CollectionStringBuffer(); 121 List<WhenDefinition> list = getWhenClauses(); 122 for (WhenDefinition whenType : list) { 123 buffer.append(whenType.getLabel()); 124 } 125 return buffer.toString(); 126 } 127 128 public List<WhenDefinition> getWhenClauses() { 129 return whenClauses; 130 } 131 132 public void setWhenClauses(List<WhenDefinition> whenClauses) { 133 this.whenClauses = whenClauses; 134 } 135 136 @SuppressWarnings("unchecked") 137 public List<ProcessorDefinition> getOutputs() { 138 if (otherwise != null) { 139 return otherwise.getOutputs(); 140 } else if (whenClauses.isEmpty()) { 141 return Collections.EMPTY_LIST; 142 } else { 143 WhenDefinition when = whenClauses.get(whenClauses.size() - 1); 144 return when.getOutputs(); 145 } 146 } 147 148 public OtherwiseDefinition getOtherwise() { 149 return otherwise; 150 } 151 152 public void setOtherwise(OtherwiseDefinition otherwise) { 153 this.otherwise = otherwise; 154 } 155 156 }