2009/05/20 - Apache Shale has been retired.

 /*

  * Licensed to the Apache Software Foundation (ASF) under one or more

  * contributor license agreements.  See the NOTICE file distributed with

  * this work for additional information regarding copyright ownership.

  * The ASF licenses this file to you under the Apache License, Version 2.0

  * (the "License"); you may not use this file except in compliance with

  * the License.  You may obtain a copy of the License at

  *

  *      http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.apache.shale.tiger.view.faces;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 import java.io.File;

 import java.io.FileFilter;

 import java.io.IOException;

 import java.net.JarURLConnection;

 import java.net.URISyntaxException;

 import java.net.URL;

 import java.net.URLConnection;

 import java.util.Enumeration;

 import java.util.List;

 import java.util.jar.JarEntry;

 import java.util.jar.JarFile;

 /**

  * <p>Utility class with methods that support getting a recursive list of

  * classes starting with a specific package name.</p>

  */

 public final class PackageInfo {

     /**

      * <p>The <code>Log</code> instance we will be using.</p>

      */

     private transient Log log = null;

     /**

      * the singleton for this class

      */

     private final static PackageInfo INSTANCE = new PackageInfo();

     /**

      * <p>Get the singleton instance of this class.</p>

      */

     public final static PackageInfo getInstance() {

         return INSTANCE;

     }

     /**

      * <p>Return an array of all classes, visible to our application class loader,

      * in the specified Java package.</p>

      *

      * @param classes List of matching classes being accumulated

      * @param pckgname Package name used to select matching classes

      *

      * @throws ClassNotFoundException

      */

     public Class[] getClasses(final List<Class> classes, final String pckgname)

       throws ClassNotFoundException {

         Enumeration resources;

         ClassLoader cld;

         String path;

         try {

             // convert the package name to a path

             path = pckgname.replace('.', '/');

             cld = Thread.currentThread().getContextClassLoader();

             if (cld == null) {

                 throw new ClassNotFoundException("Can't get class loader.");

             }

             // find the entry points to the classpath

             resources = cld.getResources(path);

             if (resources == null || !resources.hasMoreElements()) {

                 throw new ClassNotFoundException("No resource for " + path);

             }

         } catch (NullPointerException e) {

             throw(ClassNotFoundException) new ClassNotFoundException(pckgname + " (" + pckgname

                     + ") does not appear to be a valid package", e);

         } catch (IOException e) {

             throw(ClassNotFoundException) new ClassNotFoundException(pckgname + " (" + pckgname

                     + ") does not appear to be a valid package", e);

         }

         // iterate through all resources containing the package in question

         while (resources.hasMoreElements()) {

             URL resource = (URL) resources.nextElement();

             URLConnection connection = null;

             try {

                 connection = resource.openConnection();

             } catch (IOException e) {

                 throw(ClassNotFoundException) new ClassNotFoundException(pckgname + " (" + pckgname

                         + ") does not appear to be a valid package", e);

             }

             if (connection instanceof JarURLConnection) {

                 // iterate trhough all the entries in the jar

                 JarURLConnection juc = (JarURLConnection) connection;

                 JarFile jarFile = null;

                 try {

                     jarFile = juc.getJarFile();

                 } catch (IOException e) {

                     throw(ClassNotFoundException) new ClassNotFoundException(pckgname + " (" + pckgname

                             + ") does not appear to be a valid package", e);

                 }

                 Enumeration<JarEntry> entries = jarFile.entries();

                 while (entries.hasMoreElements()) {

                     JarEntry jarEntry = entries.nextElement();

                     String entryName = jarEntry.getName();

                     if (!entryName.startsWith(path)) {

                         continue;

                     }

                     if (!entryName.toLowerCase().endsWith(".class")) {

                         continue;

                     }

                     String className = filenameToClassname(entryName);

                     loadClass(classes, cld, className);

                 }

             } else {

                 // iterate trhough all the children starting with the package name

                 File file;

                 try {

                     file = new File(connection.getURL().toURI());

                 } catch (URISyntaxException e) {

                     log().warn("error loading directory " + connection, e);

                     continue;

                 }

                 listFilesRecursive(classes, file, cld, pckgname);

             }

         }

         if (classes.size() < 1) {

             throw new ClassNotFoundException(pckgname

                     + " does not appear to be a valid package");

         }

         Class[] resolvedClasses = new Class[classes.size()];

         classes.toArray(resolvedClasses);

         return resolvedClasses;

     }

     /**

      * <p>Convert a filename to a classname.</p>

      *

      * @param entryName Filename to be converted

      */

     protected String filenameToClassname(String entryName) {

         return entryName.substring(0, entryName.length() - 6).replace('/', '.');

     }

     /**

      * <p>Load the class <code>className</code> using the classloader

      * <code>cld</code>, and add it to the list.</p>

      *

      * @param classes List of matching classes being accumulated

      * @param cld ClassLoader from which to load the specified class

      * @param className Name of the class to be loaded

      */

     protected void loadClass(List<Class> classes, ClassLoader cld, String className) {

         try {

             classes.add(cld.loadClass(className));

         }

         catch (NoClassDefFoundError e) {

             log().warn("error loading class " + className, e);

         } catch (ClassNotFoundException e) {

             log().warn("error loading class " + className, e);

         }

     }

     /**

      * <p>Traverse a directory structure starting at <code>base</code>, adding

      * matching files to the specified list.</p>

      *

      * @param classes List of matching classes being accumulated

      * @param base Base file from which to recurse

      * @param cld ClassLoader being searched for matching classes

      * @param pckgname Package name used to select matching classes

      */

     protected void listFilesRecursive(final List<Class> classes, final File base,

             final ClassLoader cld, final String pckgname) {

         base.listFiles(new FileFilter() {

             public boolean accept(File file) {

                 if (file.isDirectory()) {

                     listFilesRecursive(classes, file, cld, pckgname + "." + file.getName());

                     return false;

                 }

                 if (!file.getName().toLowerCase().endsWith(".class")) {

                     return false;

                 }

                 String className = filenameToClassname(pckgname + "." + file.getName());

                 loadClass(classes, cld, className);

                 return false;

             }

         });

     }

     /**

      * <p>Return the <code>Log</code> instance to be used for this class,

      * instantiating a new one if necessary.</p>

      */

     private Log log() {

         if (log == null) {

             log = LogFactory.getLog(PackageInfo.class);

         }

         return log;

     }

 }