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    
018    package org.apache.geronimo.kernel;
019    
020    import java.lang.reflect.Array;
021    import java.util.HashMap;
022    import java.util.Set;
023    import java.util.LinkedHashSet;
024    import java.util.LinkedList;
025    import java.util.Arrays;
026    import java.util.List;
027    import java.util.ArrayList;
028    
029    import org.apache.geronimo.kernel.config.MultiParentClassLoader;
030    
031    /**
032     * Utility class for loading classes by a variety of name variations.
033     * <p/>
034     * Supported names types are:
035     * <p/>
036     * 1)  Fully qualified class name (e.g., "java.lang.String", "org.apache.geronimo.kernel.ClassLoading"
037     * 2)  Method signature encoding ("Ljava.lang.String;", "J", "I", etc.)
038     * 3)  Primitive type names ("int", "boolean", etc.)
039     * 4)  Method array signature strings ("[I", "[Ljava.lang.String")
040     * 5)  Arrays using Java code format ("int[]", "java.lang.String[][]")
041     * <p/>
042     * The classes are loaded using the provided class loader.  For the basic types, the primitive
043     * reflection types are returned.
044     *
045     * @version $Rev: 476049 $
046     */
047    public class ClassLoading {
048    
049        /**
050         * Table for mapping primitive class names/signatures to the implementing
051         * class object
052         */
053        private static final HashMap PRIMITIVE_CLASS_MAP = new HashMap();
054    
055        /**
056         * Table for mapping primitive classes back to their name signature type, which
057         * allows a reverse mapping to be performed from a class object into a resolvable
058         * signature.
059         */
060        private static final HashMap CLASS_TO_SIGNATURE_MAP = new HashMap();
061    
062    
063        /**
064         * Setup the primitives map.  We make any entry for each primitive class using both the
065         * human readable name and the method signature shorthand type.
066         */
067        static {
068            PRIMITIVE_CLASS_MAP.put("boolean", boolean.class);
069            PRIMITIVE_CLASS_MAP.put("Z", boolean.class);
070            PRIMITIVE_CLASS_MAP.put("byte", byte.class);
071            PRIMITIVE_CLASS_MAP.put("B", byte.class);
072            PRIMITIVE_CLASS_MAP.put("char", char.class);
073            PRIMITIVE_CLASS_MAP.put("C", char.class);
074            PRIMITIVE_CLASS_MAP.put("short", short.class);
075            PRIMITIVE_CLASS_MAP.put("S", short.class);
076            PRIMITIVE_CLASS_MAP.put("int", int.class);
077            PRIMITIVE_CLASS_MAP.put("I", int.class);
078            PRIMITIVE_CLASS_MAP.put("long", long.class);
079            PRIMITIVE_CLASS_MAP.put("J", long.class);
080            PRIMITIVE_CLASS_MAP.put("float", float.class);
081            PRIMITIVE_CLASS_MAP.put("F", float.class);
082            PRIMITIVE_CLASS_MAP.put("double", double.class);
083            PRIMITIVE_CLASS_MAP.put("D", double.class);
084            PRIMITIVE_CLASS_MAP.put("void", void.class);
085            PRIMITIVE_CLASS_MAP.put("V", void.class);
086    
087            // Now build a reverse mapping table.  The table above has a many-to-one mapping for
088            // class names.  To do the reverse, we need to pick just one.  As long as the
089            // returned name supports "round tripping" of the requests, this will work fine.
090    
091            CLASS_TO_SIGNATURE_MAP.put(boolean.class, "Z");
092            CLASS_TO_SIGNATURE_MAP.put(byte.class, "B");
093            CLASS_TO_SIGNATURE_MAP.put(char.class, "C");
094            CLASS_TO_SIGNATURE_MAP.put(short.class, "S");
095            CLASS_TO_SIGNATURE_MAP.put(int.class, "I");
096            CLASS_TO_SIGNATURE_MAP.put(long.class, "J");
097            CLASS_TO_SIGNATURE_MAP.put(float.class, "F");
098            CLASS_TO_SIGNATURE_MAP.put(double.class, "D");
099            CLASS_TO_SIGNATURE_MAP.put(void.class, "V");
100        }
101    
102    
103        /**
104         * Load a class that matches the requested name, using the provided class loader context.
105         * <p/>
106         * The class name may be a standard class name, the name of a primitive type Java
107         * reflection class (e.g., "boolean" or "int"), or a type in method type signature
108         * encoding.  Array classes in either encoding form are also processed.
109         *
110         * @param className The name of the required class.
111         * @param classLoader The class loader used to resolve the class object.
112         * @return The Class object resolved from "className".
113         * @throws ClassNotFoundException When unable to resolve the class object.
114         * @throws IllegalArgumentException If either argument is null.
115         */
116        public static Class loadClass(String className, ClassLoader classLoader) throws ClassNotFoundException {
117    
118            // the tests require IllegalArgumentExceptions for null values on either of these.
119            if (className == null) {
120                throw new IllegalArgumentException("className is null");
121            }
122    
123            if (classLoader == null) {
124                throw new IllegalArgumentException("classLoader is null");
125            }
126            // The easiest case is a proper class name.  We just have the class loader resolve this.
127            // If the class loader throws a ClassNotFoundException, then we need to check each of the
128            // special name encodings we support.
129            try {
130                return classLoader.loadClass(className);
131            } catch (ClassNotFoundException ignore) {
132                // if not found, continue on to the other name forms.
133            }
134    
135    
136            // The second easiest version to resolve is a direct map to a primitive type name
137            // or method signature.  Check our name-to-class map for one of those.
138            Class resolvedClass = (Class) PRIMITIVE_CLASS_MAP.get(className);
139            if (resolvedClass != null) {
140                return resolvedClass;
141            }
142    
143            // Class names in method signature have the format "Lfully.resolved.name;",
144            // so if it ends in a semicolon and begins with an "L", this must be in
145            // this format.  Have the class loader try to load this.  There are no other
146            // options if this fails, so just allow the class loader to throw the
147            // ClassNotFoundException.
148            if (className.endsWith(";") && className.startsWith("L")) {
149                // pick out the name portion
150                String typeName = className.substring(1, className.length() - 1);
151                // and delegate the loading to the class loader.
152                return classLoader.loadClass(typeName);
153            }
154    
155            // All we have left now are the array types.  Method signature array types
156            // have a series of leading "[" characters to specify the number of dimensions.
157            // The other array type we handle uses trailing "[]" for the dimensions, just
158            // like the Java language syntax.
159    
160            // first check for the signature form ([[[[type).
161            if (className.charAt(0) == '[') {
162                // we have at least one array marker, now count how many leading '['s we have
163                // to get the dimension count.
164                int count = 0;
165                int nameLen = className.length();
166    
167                while (count < nameLen && className.charAt(count) == '[') {
168                    count++;
169                }
170    
171                // pull of the name subtype, which is everything after the last '['
172                String arrayTypeName = className.substring(count, className.length());
173                // resolve the type using a recursive call, which will load any of the primitive signature
174                // types as well as class names.
175                Class arrayType = loadClass(arrayTypeName, classLoader);
176    
177                // Resolving array types require a little more work.  The array classes are
178                // created dynamically when the first instance of a given dimension and type is
179                // created.  We need to create one using reflection to do this.
180                return getArrayClass(arrayType, count);
181            }
182    
183    
184            // ok, last chance.  Now check for an array specification in Java language
185            // syntax.  This will be a type name followed by pairs of "[]" to indicate
186            // the number of dimensions.
187            if (className.endsWith("[]")) {
188                // get the base component class name and the arrayDimensions
189                int count = 0;
190                int position = className.length();
191    
192                while (position > 1 && className.substring(position - 2, position).equals("[]")) {
193                    // count this dimension
194                    count++;
195                    // and step back the probe position.
196                    position -= 2;
197                }
198    
199                // position now points at the location of the last successful test.  This makes it
200                // easy to pick off the class name.
201    
202                String typeName = className.substring(0, position);
203    
204                // load the base type, again, doing this recursively
205                Class arrayType = loadClass(typeName, classLoader);
206                // and turn this into the class object
207                return getArrayClass(arrayType, count);
208            }
209    
210            // We're out of options, just toss an exception over the wall.
211            if (classLoader instanceof MultiParentClassLoader) {
212                MultiParentClassLoader cl = (MultiParentClassLoader) classLoader;
213                throw new ClassNotFoundException("Could not load class " + className + " from classloader: " + cl.getId() + ", destroyed state: " + cl.isDestroyed());
214            }
215            throw new ClassNotFoundException("Could not load class " + className + " from unknown classloader; " + classLoader);
216        }
217    
218    
219        /**
220         * Map a class object back to a class name.  The returned class object
221         * must be "round trippable", which means
222         * <p/>
223         * type == ClassLoading.loadClass(ClassLoading.getClassName(type), classLoader)
224         * <p/>
225         * must be true.  To ensure this, the class name is always returned in
226         * method signature format.
227         *
228         * @param type The class object we convert into name form.
229         * @return A string representation of the class name, in method signature
230         *         format.
231         */
232        public static String getClassName(Class type) {
233            StringBuffer name = new StringBuffer();
234    
235            // we test these in reverse order from the resolution steps,
236            // first handling arrays, then primitive types, and finally
237            // "normal" class objects.
238    
239            // First handle arrays.  If a class is an array, the type is
240            // element stored at that level.  So, for a 2-dimensional array
241            // of ints, the top-level type will be "[I".  We need to loop
242            // down the hierarchy until we hit a non-array type.
243            while (type.isArray()) {
244                // add another array indicator at the front of the name,
245                // and continue with the next type.
246                name.append('[');
247                type = type.getComponentType();
248            }
249    
250            // we're down to the base type.  If this is a primitive, then
251            // we poke in the single-character type specifier.
252            if (type.isPrimitive()) {
253                name.append((String) CLASS_TO_SIGNATURE_MAP.get(type));
254            }
255            // a "normal" class.  This gets expressing using the "Lmy.class.name;" syntax.
256            else {
257                name.append('L');
258                name.append(type.getName());
259                name.append(';');
260            }
261            return name.toString();
262        }
263    
264        private static Class getArrayClass(Class type, int dimension) {
265            // Array.newInstance() requires an array of the requested number of dimensions
266            // that gives the size for each dimension.  We just request 0 in each of the
267            // dimentions, which is not unlike a black hole sigularity.
268            int dimensions[] = new int[dimension];
269            // create an instance and return the associated class object.
270            return Array.newInstance(type, dimensions).getClass();
271        }
272    
273        public static Set getAllTypes(Class type) {
274            Set allTypes = new LinkedHashSet();
275            allTypes.add(type);
276            allTypes.addAll(getAllSuperClasses(type));
277            allTypes.addAll(getAllInterfaces(type));
278            return allTypes;
279        }
280    
281        private static Set getAllSuperClasses(Class clazz) {
282            Set allSuperClasses = new LinkedHashSet();
283            for (Class superClass = clazz.getSuperclass(); superClass != null; superClass = superClass.getSuperclass()) {
284                allSuperClasses.add(superClass);
285            }
286            return allSuperClasses;
287        }
288    
289        private static Set getAllInterfaces(Class clazz) {
290            Set allInterfaces = new LinkedHashSet();
291            LinkedList stack = new LinkedList();
292            stack.addAll(Arrays.asList(clazz.getInterfaces()));
293            while (!stack.isEmpty()) {
294                Class intf = (Class) stack.removeFirst();
295                if (!allInterfaces.contains(intf)) {
296                    allInterfaces.add(intf);
297                    stack.addAll(Arrays.asList(intf.getInterfaces()));
298                }
299            }
300            return allInterfaces;
301        }
302    
303        public static Set reduceInterfaces(Set source) {
304            Class[] classes = (Class[]) source.toArray(new Class[source.size()]);
305            classes = reduceInterfaces(classes);
306            return new LinkedHashSet(Arrays.asList(classes));
307        }
308    
309        /**
310         * If there are multiple interfaces, and some of them extend each other,
311         * eliminate the superclass in favor of the subclasses that extend them.
312         *
313         * If one of the entries is a class (not an interface), make sure it's
314         * the first one in the array.  If more than one of the entries is a
315         * class, throws an IllegalArgumentException
316         *
317         * @param source the original list of interfaces
318         * @return the equal or smaller list of interfaces
319         */
320        public static Class[] reduceInterfaces(Class[] source) {
321            // use a copy of the sorce array
322            source = (Class[]) source.clone();
323    
324            for (int leftIndex = 0; leftIndex < source.length-1; leftIndex++) {
325                Class left = source[leftIndex];
326                if(left == null) {
327                    continue;
328                }
329    
330                for (int rightIndex = leftIndex +1; rightIndex < source.length; rightIndex++) {
331                    Class right = source[rightIndex];
332                    if(right == null) {
333                        continue;
334                    }
335    
336                    if(left == right || right.isAssignableFrom(left)) {
337                        // right is the same as class or a sub class of left
338                        source[rightIndex] = null;
339                    } else if(left.isAssignableFrom(right)) {
340                        // left is the same as class or a sub class of right
341                        source[leftIndex] = null;
342    
343                        // the left has been eliminated; move on to the next left
344                        break;
345                    }
346                }
347            }
348    
349            Class clazz = null;
350            for (int i = 0; i < source.length; i++) {
351                if (source[i] != null && !source[i].isInterface()) {
352                    if (clazz != null) {
353                        throw new IllegalArgumentException("Source contains two classes which are not subclasses of each other: " + clazz.getName() + ", " + source[i].getName());
354                    }
355                    clazz = source[i];
356                    source[i] = null;
357                }
358            }
359    
360            List list = new ArrayList(source.length);
361            if (clazz != null) list.add(clazz);
362            for (int i = 0; i < source.length; i++) {
363                if(source[i] != null) {
364                    list.add(source[i]);
365                }
366            }
367            return (Class[]) list.toArray(new Class[list.size()]);
368        }
369    }
370