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.util;
018
019
020 import java.util.ArrayList;
021 import java.util.Collection;
022 import java.util.List;
023
024 import org.apache.camel.CamelContext;
025 import org.apache.camel.Endpoint;
026 import org.apache.camel.Exchange;
027 import org.apache.camel.Expression;
028 import org.apache.camel.NoSuchEndpointException;
029 import org.apache.camel.spi.Injector;
030 import org.apache.camel.spi.Language;
031 import org.apache.camel.spi.Registry;
032 import static org.apache.camel.util.ObjectHelper.notNull;
033
034 /**
035 * A number of helper methods
036 *
037 * @version $Revision: 673837 $
038 */
039 public final class CamelContextHelper {
040 /**
041 * Utility classes should not have a public constructor.
042 */
043 private CamelContextHelper() {
044 }
045
046 /**
047 * Returns the mandatory endpoint for the given URI or the
048 * {@link org.apache.camel.NoSuchEndpointException} is thrown
049 */
050 public static Endpoint getMandatoryEndpoint(CamelContext camelContext, String uri)
051 throws NoSuchEndpointException {
052 Endpoint endpoint = camelContext.getEndpoint(uri);
053 if (endpoint == null) {
054 throw new NoSuchEndpointException(uri);
055 } else {
056 return endpoint;
057 }
058 }
059
060 /**
061 * Returns the mandatory endpoint for the given URI and type or the
062 * {@link org.apache.camel.NoSuchEndpointException} is thrown
063 */
064 public static <T extends Endpoint> T getMandatoryEndpoint(CamelContext camelContext, String uri, Class<T> type) {
065 Endpoint endpoint = getMandatoryEndpoint(camelContext, uri);
066 return ObjectHelper.cast(type, endpoint);
067 }
068
069 /**
070 * Returns a list of all endpoints of the given type
071 *
072 * @param camelContext
073 * @param type the type of the endpoints requested
074 * @return a list which may be empty of all the endpoint instances of the
075 * given type
076 */
077 public static <T> List<T> getSingletonEndpoints(CamelContext camelContext, Class<T> type) {
078 List<T> answer = new ArrayList<T>();
079 Collection<Endpoint> endpoints = camelContext.getSingletonEndpoints();
080 for (Endpoint endpoint : endpoints) {
081 if (type.isInstance(endpoint)) {
082 T value = type.cast(endpoint);
083 answer.add(value);
084 }
085 }
086 return answer;
087 }
088
089 /**
090 * Converts the given value to the requested type
091 */
092 public static <T> T convertTo(CamelContext context, Class<T> type, Object value) {
093 notNull(context, "camelContext");
094 return context.getTypeConverter().convertTo(type, value);
095 }
096
097 /**
098 * Converts the given value to the specified type throwing an {@link IllegalArgumentException}
099 * if the value could not be converted to a non null value
100 */
101 public static <T> T mandatoryConvertTo(CamelContext context, Class<T> type, Object value) {
102 T answer = convertTo(context, type, value);
103 if (answer == null) {
104 throw new IllegalArgumentException("Value " + value + " converted to " + type.getName() + " cannot be null");
105 }
106 return answer;
107 }
108
109 /**
110 * Creates a new instance of the given type using the {@link Injector} on the given
111 * {@link CamelContext}
112 */
113 public static <T> T newInstance(CamelContext context, Class<T> beanType) {
114 return context.getInjector().newInstance(beanType);
115 }
116
117 /**
118 * Look up the given named bean in the {@link Registry} on the
119 * {@link CamelContext}
120 */
121 public static Object lookup(CamelContext context, String name) {
122 return context.getRegistry().lookup(name);
123 }
124
125 /**
126 * Look up the given named bean of the given type in the {@link Registry} on the
127 * {@link CamelContext}
128 */
129 public static <T> T lookup(CamelContext context, String name, Class<T> beanType) {
130 return context.getRegistry().lookup(name, beanType);
131 }
132
133 /**
134 * Look up the given named bean in the {@link Registry} on the
135 * {@link CamelContext} or throws
136 */
137 public static Object mandatoryLookup(CamelContext context, String name) {
138 Object answer = lookup(context, name);
139 notNull(answer, "registry entry called " + name);
140 return answer;
141 }
142
143 /**
144 * Look up the given named bean of the given type in the {@link Registry} on the
145 * {@link CamelContext}
146 */
147 public static <T> T mandatoryLookup(CamelContext context, String name, Class<T> beanType) {
148 T answer = lookup(context, name, beanType);
149 notNull(answer, "registry entry called " + name + " of type " + beanType.getName());
150 return answer;
151 }
152
153 /**
154 * Resolves the given language name into a {@link Language} or throws an exception if it could not be converted
155 */
156 public static Language resolveMandatoryLanguage(CamelContext camelContext, String languageName) {
157 notNull(camelContext, "camelContext");
158 notNull(languageName, "languageName");
159
160 Language language = camelContext.resolveLanguage(languageName);
161 if (language == null) {
162 throw new IllegalArgumentException("Could not resolve language: " + languageName);
163 }
164 return language;
165 }
166
167 /**
168 * Resolves the mandatory language name and expression text into a {@link Expression} instance
169 * throwing an exception if it could not be created
170 */
171 public static Expression resolveMandatoryExpression(CamelContext camelContext, String languageName, String expressionText) {
172 notNull(expressionText, "expressionText");
173
174 Language language = resolveMandatoryLanguage(camelContext, languageName);
175 Expression<Exchange> expression = language.createExpression(expressionText);
176 if (expression == null) {
177 throw new IllegalArgumentException("Could not create expression: " + expressionText + " with language: " + language);
178 }
179 return expression;
180 }
181 }