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.List;
021    
022    import javax.xml.bind.annotation.XmlAccessType;
023    import javax.xml.bind.annotation.XmlAccessorType;
024    import javax.xml.bind.annotation.XmlAttribute;
025    import javax.xml.bind.annotation.XmlElementRef;
026    import javax.xml.bind.annotation.XmlRootElement;
027    import javax.xml.bind.annotation.XmlTransient;
028    
029    import org.apache.camel.CamelContext;
030    import org.apache.camel.Endpoint;
031    import org.apache.camel.Predicate;
032    import org.apache.camel.Route;
033    import org.apache.camel.builder.ErrorHandlerBuilder;
034    import org.apache.camel.processor.DelegateProcessor;
035    
036    /**
037     * Represents a collection of routes
038     *
039     * @version $Revision: 35332 $
040     */
041    @XmlRootElement(name = "routes")
042    @XmlAccessorType(XmlAccessType.FIELD)
043    public class RoutesType implements RouteContainer {
044        // TODO: not sure how else to use an optional attribute in JAXB2
045        @XmlAttribute
046        private Boolean inheritErrorHandlerFlag = Boolean.TRUE;
047        @XmlElementRef
048        private List<RouteType> routes = new ArrayList<RouteType>();
049        @XmlElementRef
050        private List<ServiceActivationType> activations = new ArrayList<ServiceActivationType>();
051        @XmlTransient
052        private List<InterceptorType> interceptors = new ArrayList<InterceptorType>();
053        @XmlTransient
054        private List<InterceptType> intercepts = new ArrayList<InterceptType>();
055        @XmlTransient
056        private List<ExceptionType> exceptions = new ArrayList<ExceptionType>();
057        @XmlTransient
058        private CamelContext camelContext;
059        @XmlTransient
060        private ErrorHandlerBuilder errorHandlerBuilder;
061    
062        @Override
063        public String toString() {
064            return "Routes: " + routes;
065        }
066    
067        // Properties
068        //-----------------------------------------------------------------------
069        public List<RouteType> getRoutes() {
070            return routes;
071        }
072    
073        public void setRoutes(List<RouteType> routes) {
074            this.routes = routes;
075        }
076    
077        public List<InterceptorType> getInterceptors() {
078            return interceptors;
079        }
080    
081        public void setInterceptors(List<InterceptorType> interceptors) {
082            this.interceptors = interceptors;
083        }
084    
085        public List<InterceptType> getIntercepts() {
086            return intercepts;
087        }
088    
089        public void setIntercepts(List<InterceptType> intercepts) {
090            this.intercepts = intercepts;
091        }
092    
093        public List<ExceptionType> getExceptions() {
094            return exceptions;
095        }
096    
097        public void setExceptions(List<ExceptionType> exceptions) {
098            this.exceptions = exceptions;
099        }
100    
101        public CamelContext getCamelContext() {
102            return camelContext;
103        }
104    
105        public void setCamelContext(CamelContext camelContext) {
106            this.camelContext = camelContext;
107        }
108    
109        public boolean isInheritErrorHandler() {
110            return inheritErrorHandlerFlag != null && inheritErrorHandlerFlag.booleanValue();
111        }
112    
113        public Boolean getInheritErrorHandlerFlag() {
114            return inheritErrorHandlerFlag;
115        }
116    
117        public void setInheritErrorHandlerFlag(Boolean inheritErrorHandlerFlag) {
118            this.inheritErrorHandlerFlag = inheritErrorHandlerFlag;
119        }
120    
121        public ErrorHandlerBuilder getErrorHandlerBuilder() {
122            return errorHandlerBuilder;
123        }
124    
125        public void setErrorHandlerBuilder(ErrorHandlerBuilder errorHandlerBuilder) {
126            this.errorHandlerBuilder = errorHandlerBuilder;
127        }
128    
129        // Fluent API
130        //-------------------------------------------------------------------------
131    
132        /**
133         * Creates a new route
134         */
135        public RouteType route() {
136            RouteType route = createRoute();
137            return route(route);
138        }
139    
140        /**
141         * Creates a new route from the given URI input
142         */
143        public RouteType from(String uri) {
144            RouteType route = createRoute();
145            route.from(uri);
146            return route(route);
147        }
148    
149        /**
150         * Creates a new route from the given endpoint
151         */
152        public RouteType from(Endpoint endpoint) {
153            RouteType route = createRoute();
154            route.from(endpoint);
155            return route(route);
156        }
157    
158        public RouteType route(RouteType route) {
159            // lets configure the route
160            route.setCamelContext(getCamelContext());
161            route.setInheritErrorHandlerFlag(getInheritErrorHandlerFlag());
162            List<InterceptorType> list = getInterceptors();
163            for (InterceptorType interceptorType : list) {
164                route.addInterceptor(interceptorType);
165            }
166            List<InterceptType> intercepts = getIntercepts();
167            for (InterceptType intercept : intercepts) {
168                route.addOutput(intercept);
169                route.pushBlock(intercept.getProceed());
170            }
171            route.getOutputs().addAll(getExceptions());
172            getRoutes().add(route);
173            return route;
174        }
175    
176        public RoutesType intercept(DelegateProcessor interceptor) {
177            getInterceptors().add(new InterceptorRef(interceptor));
178            return this;
179        }
180    
181        public InterceptType intercept() {
182            InterceptType answer = new InterceptType();
183            getIntercepts().add(answer);
184            return answer;
185        }
186    
187        public ChoiceType intercept(Predicate predicate) {
188            InterceptType answer = new InterceptType();
189            getIntercepts().add(answer);
190            return answer.when(predicate);
191        }
192    
193        public ExceptionType exception(Class exceptionType) {
194            ExceptionType answer = new ExceptionType(exceptionType);
195            getExceptions().add(answer);
196            return answer;
197        }
198    
199        // Implementation methods
200        //-------------------------------------------------------------------------
201        protected RouteType createRoute() {
202            RouteType route = new RouteType();
203            if (isInheritErrorHandler()) {
204                route.setErrorHandlerBuilder(getErrorHandlerBuilder());
205            }
206            return route;
207        }
208    }