Subversion Repositories openrisc

package gnu.java.net.loader;

import gnu.java.net.IndexListParser;

import java.io.IOException;

import java.net.JarURLConnection;

import java.net.MalformedURLException;

import java.net.URL;

import java.net.URLClassLoader;

import java.net.URLStreamHandlerFactory;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.Map;

import java.util.Set;

import java.util.StringTokenizer;

import java.util.jar.Attributes;

import java.util.jar.JarEntry;

import java.util.jar.JarFile;

import java.util.jar.Manifest;

/**

 * A <code>JarURLLoader</code> is a type of <code>URLLoader</code>

 * only loading from jar url.

 */

public final class JarURLLoader extends URLLoader

{

  // True if we've initialized -- i.e., tried open the jar file.

  boolean initialized;

  // The jar file for this url.

  JarFile jarfile;

  // Base jar: url for all resources loaded from jar.

  final URL baseJarURL;

  // The "Class-Path" attribute of this Jar's manifest.

  ArrayList<URLLoader> classPath;

  // If not null, a mapping from INDEX.LIST for this jar only.

  // This is a set of all prefixes and top-level files that

  // ought to be available in this jar.

  Set indexSet;

  // This constructor is used internally.  It purposely does not open

  // the jar file -- it defers this until later.  This allows us to

  // implement INDEX.LIST lazy-loading semantics.

  private JarURLLoader(URLClassLoader classloader, URLStreamHandlerCache cache,

                       URLStreamHandlerFactory factory,

                       URL baseURL, URL absoluteUrl,

                       Set indexSet)

  {

    super(classloader, cache, factory, baseURL, absoluteUrl);

    URL newBaseURL = null;

    try

      {

        // Cache url prefix for all resources in this jar url.

        String base = baseURL.toExternalForm() + "!/";

        newBaseURL = new URL("jar", "", -1, base, cache.get(factory, "jar"));

      }

    catch (MalformedURLException ignore)

      {

        // Ignore.

      }

    this.baseJarURL = newBaseURL;

    this.classPath = null;

    this.indexSet = indexSet;

  }

  // This constructor is used by URLClassLoader.  It will immediately

  // try to read the jar file, in case we've found an index or a class-path

  // setting.  FIXME: it would be nice to defer this as well, but URLClassLoader

  // makes this hard.

  public JarURLLoader(URLClassLoader classloader, URLStreamHandlerCache cache,

                      URLStreamHandlerFactory factory,

                      URL baseURL, URL absoluteUrl)

  {

    this(classloader, cache, factory, baseURL, absoluteUrl, null);

    initialize();

  }

  private void initialize()

  {

    JarFile jarfile = null;

    try

      {

        jarfile =

          ((JarURLConnection) baseJarURL.openConnection()).getJarFile();

        Manifest manifest;

        Attributes attributes;

        String classPathString;

        IndexListParser parser = new IndexListParser(jarfile, baseJarURL,

                                                     baseURL);

        LinkedHashMap<URL, Set<String>> indexMap = parser.getHeaders();

        if (indexMap != null)

          {

            // Note that the index also computes

            // the resulting Class-Path -- there are jars out there

            // where the index lists some required jars which do

            // not appear in the Class-Path attribute in the manifest.

            this.classPath = new ArrayList<URLLoader>();

            Iterator<Map.Entry<URL, Set<String>>> it = indexMap.entrySet().iterator();

            while (it.hasNext())

              {

                Map.Entry<URL, Set<String>> entry = it.next();

                URL subURL = entry.getKey();

                Set<String> prefixes = entry.getValue();

                if (subURL.equals(baseURL))

                  this.indexSet = prefixes;

                else

                  {

                    JarURLLoader subLoader = new JarURLLoader(classloader,

                                                              cache,

                                                              factory, subURL,

                                                              subURL,

                                                              prefixes);

                    // Note that we don't care if the sub-loader itself has an

                    // index or a class-path -- only the top-level jar

                    // file gets this treatment; its index should cover

                    // everything.

                    this.classPath.add(subLoader);

                  }

              }

          }

        else if ((manifest = jarfile.getManifest()) != null

                 && (attributes = manifest.getMainAttributes()) != null

                 && ((classPathString

                      = attributes.getValue(Attributes.Name.CLASS_PATH))

                     != null))

          {

            this.classPath = new ArrayList<URLLoader>();

            StringTokenizer st = new StringTokenizer(classPathString, " ");

            while (st.hasMoreElements ())

              {

                String e = st.nextToken ();

                try

                  {

                    URL subURL = new URL(baseURL, e);

                    // We've seen at least one jar file whose Class-Path

                    // attribute includes the original jar.  If we process

                    // that normally we end up with infinite recursion.

                    if (subURL.equals(baseURL))

                      continue;

                    JarURLLoader subLoader = new JarURLLoader(classloader,

                                                              cache, factory,

                                                              subURL, subURL);

                    this.classPath.add(subLoader);

                    ArrayList<URLLoader> extra = subLoader.getClassPath();

                    if (extra != null)

                      this.classPath.addAll(extra);

                  }

                catch (java.net.MalformedURLException xx)

                  {

                    // Give up

                  }

              }

          }

      }

    catch (IOException ioe)

      {

        /* ignored */

      }

    this.jarfile = jarfile;

    this.initialized = true;

  }

  /** get resource with the name "name" in the jar url */

  public Resource getResource(String name)

  {

    if (name.startsWith("/"))

      name = name.substring(1);

    if (indexSet != null)

      {

        // Trust the index.

        String basename = name;

        int offset = basename.lastIndexOf('/');

        if (offset != -1)

          basename = basename.substring(0, offset);

        if (! indexSet.contains(basename))

          return null;

        // FIXME: if the index claim to hold the resource, and jar file

        // doesn't have it, we're supposed to throw an exception.  However,

        // in our model this is tricky to implement, as another URLLoader from

        // the same top-level jar may have an overlapping index entry.

      }

    if (! initialized)

      initialize();

    if (jarfile == null)

      return null;

    JarEntry je = jarfile.getJarEntry(name);

    if (je != null)

      return new JarURLResource(this, name, je);

    else

      return null;

  }

  public Manifest getManifest()

  {

    try

      {

        return (jarfile == null) ? null : jarfile.getManifest();

      }

    catch (IOException ioe)

      {

        return null;

      }

  }

  public ArrayList<URLLoader> getClassPath()

  {

    return classPath;

  }

}