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: 36635 $
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 a list of all endpoints of the given type
062 *
063 * @param camelContext
064 * @param type the type of the endpoints requested
065 * @return a list which may be empty of all the endpoint instances of the
066 * given type
067 */
068 public static <T> List<T> getSingletonEndpoints(CamelContext camelContext, Class<T> type) {
069 List<T> answer = new ArrayList<T>();
070 Collection<Endpoint> endpoints = camelContext.getSingletonEndpoints();
071 for (Endpoint endpoint : endpoints) {
072 if (type.isInstance(endpoint)) {
073 T value = type.cast(endpoint);
074 answer.add(value);
075 }
076 }
077 return answer;
078 }
079
080 /**
081 * Converts the given value to the requested type
082 */
083 public static <T> T convertTo(CamelContext context, Class<T> type, Object value) {
084 notNull(context, "camelContext");
085 return context.getTypeConverter().convertTo(type, value);
086 }
087
088 /**
089 * Converts the given value to the specified type throwing an {@link IllegalArgumentException}
090 * if the value could not be converted to a non null value
091 */
092 public static <T> T mandatoryConvertTo(CamelContext context, Class<T> type, Object value) {
093 T answer = convertTo(context, type, value);
094 if (answer == null) {
095 throw new IllegalArgumentException("Value " + value + " converted to " + type.getName() + " cannot be null");
096 }
097 return answer;
098 }
099
100 /**
101 * Creates a new instance of the given type using the {@link Injector} on the given
102 * {@link CamelContext}
103 */
104 public static <T> T newInstance(CamelContext context, Class<T> beanType) {
105 return context.getInjector().newInstance(beanType);
106 }
107
108 /**
109 * Look up the given named bean in the {@link Registry} on the
110 * {@link CamelContext}
111 */
112 public static Object lookup(CamelContext context, String name) {
113 return context.getRegistry().lookup(name);
114 }
115
116 /**
117 * Look up the given named bean of the given type in the {@link Registry} on the
118 * {@link CamelContext}
119 */
120 public static <T> T lookup(CamelContext context, String name, Class<T> beanType) {
121 return context.getRegistry().lookup(name, beanType);
122 }
123
124 /**
125 * Look up the given named bean in the {@link Registry} on the
126 * {@link CamelContext} or throws
127 */
128 public static Object mandatoryLookup(CamelContext context, String name) {
129 Object answer = lookup(context, name);
130 notNull(answer, "registry entry called " + name);
131 return answer;
132 }
133
134 /**
135 * Look up the given named bean of the given type in the {@link Registry} on the
136 * {@link CamelContext}
137 */
138 public static <T> T mandatoryLookup(CamelContext context, String name, Class<T> beanType) {
139 T answer = lookup(context, name, beanType);
140 notNull(answer, "registry entry called " + name + " of type " + beanType.getName());
141 return answer;
142 }
143
144 /**
145 * Resolves the given language name into a {@link Language} or throws an exception if it could not be converted
146 */
147 public static Language resolveMandatoryLanguage(CamelContext camelContext, String languageName) {
148 notNull(camelContext, "camelContext");
149 notNull(languageName, "languageName");
150
151 Language language = camelContext.resolveLanguage(languageName);
152 if (language == null) {
153 throw new IllegalArgumentException("Could not resolve language: " + languageName);
154 }
155 return language;
156 }
157
158 /**
159 * Resolves the mandatory language name and expression text into a {@link Expression} instance
160 * throwing an exception if it could not be created
161 */
162 public static Expression resolveMandatoryExpression(CamelContext camelContext, String languageName, String expressionText) {
163 notNull(expressionText, "expressionText");
164
165 Language language = resolveMandatoryLanguage(camelContext, languageName);
166 Expression<Exchange> expression = language.createExpression(expressionText);
167 if (expression == null) {
168 throw new IllegalArgumentException("Could not create expression: " + expressionText + " with language: " + language);
169 }
170 return expression;
171 }
172 }