jdk-sandbox: comparison jdk/src/java.base/share/classes/java/lang/Package.java

equal deleted inserted replaced

-:043f1af70518
+:9d0388c6b336
 /*
-* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * questions.
 */
 package java.lang;
+import java.lang.annotation.Annotation;
 import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Module;
-import java.io.File;
+import java.net.MalformedURLException;
-import java.io.FileInputStream;
+import java.net.URI;
-import java.io.IOException;
 import java.net.URL;
-import java.net.MalformedURLException;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
+import java.util.Objects;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.jar.JarInputStream;
+import jdk.internal.loader.BootLoader;
-import java.util.jar.Manifest;
-import java.util.jar.Attributes;
-import java.util.jar.Attributes.Name;
-import java.util.Map;
-import sun.net.www.ParseUtil;
 import sun.reflect.CallerSensitive;
 import sun.reflect.Reflection;
-import java.lang.annotation.Annotation;
 /**
-* {@code Package} objects contain version information
+* Represents metadata about a run-time package associated with a class loader.
-* about the implementation and specification of a Java package.
+* Metadata includes annotations, versioning, and sealing.
-* This versioning information is retrieved and made available
+* <p>
-* by the {@link ClassLoader} instance that
+* Annotations for the run-time package are read from {@code package-info.class}
-* loaded the class(es).  Typically, it is stored in the manifest that is
+* at the same code source as classes in the run-time package.
-* distributed with the classes.
+* <p>
-*
+* The set of classes that make up the run-time package may implement a
-* <p>The set of classes that make up the package may implement a
+* particular specification. The specification title, version, and vendor
-* particular specification and if so the specification title, version number,
+* (indicating the owner/maintainer of the specification) can be provided
-* and vendor strings identify that specification.
+* when the {@code Package} is defined. An application can ask if the
-* An application can ask if the package is
+* {@code Package} is compatible with a particular specification version
-* compatible with a particular version, see the {@link
+* by using the {@link #isCompatibleWith Package.isCompatibleWith(String)}
-* #isCompatibleWith isCompatibleWith}
+* method. In addition, information about the actual classes that make up the
-* method for details.
+* run-time package can be provided when the Package is defined.
-*
+* This information consists of an implementation title, version, and vendor
-* <p>Specification version numbers use a syntax that consists of nonnegative
+* (indicating the supplier of the classes).
-* decimal integers separated by periods ".", for example "2.0" or
+* <p>
-* "1.2.3.4.5.6.7".  This allows an extensible number to be used to represent
+* A {@code Package} may be explicitly defined with
-* major, minor, micro, etc. versions.  The version specification is described
+* the {@link ClassLoader#definePackage(String, String, String, String,
-* by the following formal grammar:
+* String, String, String, URL)} method.
-* <blockquote>
+* The caller supplies the specification and implementation titles, versions, and
-* <dl>
+* vendors. The caller also indicates whether the package is
-* <dt><i>SpecificationVersion:</i>
+* {@linkplain java.util.jar.Attributes.Name#SEALED sealed}.
-* <dd><i>Digits RefinedVersion<sub>opt</sub></i>
+* If a {@code Package} is not explicitly defined for a run-time package when
+* a class in that run-time package is defined, then a {@code Package} is
-* <dt><i>RefinedVersion:</i>
+* automatically defined by the class's defining class loader, as follows.
-* <dd>{@code .} <i>Digits</i>
+* <p>
-* <dd>{@code .} <i>Digits RefinedVersion</i>
+* A {@code Package} automatically defined for classes in a named module has
-*
+* the following properties:
-* <dt><i>Digits:</i>
+* <ul>
-* <dd><i>Digit</i>
+* <li>The name of the package is derived from the {@linkplain Class#getName() binary names}
-* <dd><i>Digits</i>
+*     of the classes. Since classes in a named module must be in a named package,
-*
+*     the derived name is never empty.</li>
-* <dt><i>Digit:</i>
+* <li>The package is sealed with the {@linkplain java.lang.module.ModuleReference#location()
-* <dd>any character for which {@link Character#isDigit} returns {@code true},
+*     module location} as the code source, if known.</li>
-* e.g. 0, 1, 2, ...
+* <li>The specification and implementation titles, versions, and vendors
-* </dl>
+*     are unspecified.</li>
-* </blockquote>
+* <li>Any annotations on the package are read from {@code package-info.class}
-*
+*     as specified above.</li>
-* <p>The implementation title, version, and vendor strings identify an
+* </ul>
-* implementation and are made available conveniently to enable accurate
+* <p>
-* reporting of the packages involved when a problem occurs. The contents
+* A {@code Package} automatically defined for classes in an unnamed module
-* all three implementation strings are vendor specific. The
+* has the following properties:
-* implementation version strings have no specified syntax and should
+* <ul>
-* only be compared for equality with desired version identifiers.
+* <li>The name of the package is either {@code ""} (for classes in an unnamed package)
-*
+*     or derived from the {@linkplain Class#getName() binary names} of the classes
-* <p>Within each {@code ClassLoader} instance all classes from the same
+*     (for classes in a named package).</li>
-* java package have the same Package object.  The static methods allow a package
+* <li>The package is not sealed.</li>
-* to be found by name or the set of all packages known to the current class
+* <li>The specification and implementation titles, versions, and vendors
-* loader to be found.
+*     are unspecified.</li>
-*
+* <li>Any annotations on the package are read from {@code package-info.class}
-* @see ClassLoader#definePackage
+*     as specified above.</li>
+* </ul>
+*
+* <p>
+* A {@code Package} can be obtained with the {@link Package#getPackage
+* Package.getPackage(String)} and {@link ClassLoader#getDefinedPackage
+* ClassLoader.getDefinedPackage(String)} methods.
+* Every {@code Package} defined by a class loader can be obtained
+* with the {@link Package#getPackages Package.getPackages()} and
+* {@link ClassLoader#getDefinedPackages} methods.
+*
+* @jvms 5.3 Run-time package
+* @see <a href="../../../technotes/guides/jar/jar.html#versioning">
+* The JAR File Specification: Package Versioning</a>
+* @see <a href="../../../technotes/guides/jar/jar.html#sealing">
+* The JAR File Specification: Package Sealing</a>
+* @see ClassLoader#definePackage(String, String, String, String, String, String, String, URL)
+*
 * @since 1.2
 */
-public class Package implements java.lang.reflect.AnnotatedElement {
+public class Package extends NamedPackage implements java.lang.reflect.AnnotatedElement {
 /**
 * Return the name of this package.
 *
 * @return  The fully-qualified name of this package as defined in section 6.5.3 of
 *          <cite>The Java&trade; Language Specification</cite>,
 *          for example, {@code java.lang}
 */
 public String getName() {
-return pkgName;
+return packageName();
 }
 /**
 * Return the title of the specification that this package implements.
-* @return the specification title, null is returned if it is not known.
+* @return the specification title, {@code null} is returned if it is not known.
 */
 public String getSpecificationTitle() {
-return specTitle;
+return versionInfo.specTitle;
 }
 /**
 * Returns the version number of the specification
 * that this package implements.
-* This version string must be a sequence of nonnegative decimal
+* This version string must be a sequence of non-negative decimal
 * integers separated by "."'s and may have leading zeros.
 * When version strings are compared the most significant
 * numbers are compared.
-* @return the specification version, null is returned if it is not known.
+*
+*
+* <p>Specification version numbers use a syntax that consists of non-negative
+* decimal integers separated by periods ".", for example "2.0" or
+* "1.2.3.4.5.6.7".  This allows an extensible number to be used to represent
+* major, minor, micro, etc. versions.  The version specification is described
+* by the following formal grammar:
+* <blockquote>
+* <dl>
+* <dt><i>SpecificationVersion:</i>
+* <dd><i>Digits RefinedVersion<sub>opt</sub></i>
+* <dt><i>RefinedVersion:</i>
+* <dd>{@code .} <i>Digits</i>
+* <dd>{@code .} <i>Digits RefinedVersion</i>
+*
+* <dt><i>Digits:</i>
+* <dd><i>Digit</i>
+* <dd><i>Digits</i>
+*
+* <dt><i>Digit:</i>
+* <dd>any character for which {@link Character#isDigit} returns {@code true},
+* e.g. 0, 1, 2, ...
+* </dl>
+* </blockquote>
+*
+* @return the specification version, {@code null} is returned if it is not known.
 */
 public String getSpecificationVersion() {
-return specVersion;
+return versionInfo.specVersion;
 }
 /**
 * Return the name of the organization, vendor,
 * or company that owns and maintains the specification
 * of the classes that implement this package.
-* @return the specification vendor, null is returned if it is not known.
+* @return the specification vendor, {@code null} is returned if it is not known.
 */
 public String getSpecificationVendor() {
-return specVendor;
+return versionInfo.specVendor;
 }
 /**
 * Return the title of this package.
-* @return the title of the implementation, null is returned if it is not known.
+* @return the title of the implementation, {@code null} is returned if it is not known.
 */
 public String getImplementationTitle() {
-return implTitle;
+return versionInfo.implTitle;
 }
 /**
 * Return the version of this implementation. It consists of any string
 * assigned by the vendor of this implementation and does
 * not have any particular syntax specified or expected by the Java
 * runtime. It may be compared for equality with other
 * package version strings used for this implementation
 * by this vendor for this package.
-* @return the version of the implementation, null is returned if it is not known.
+* @return the version of the implementation, {@code null} is returned if it is not known.
 */
 public String getImplementationVersion() {
-return implVersion;
+return versionInfo.implVersion;
 }
 /**
-* Returns the name of the organization,
+* Returns the vendor that implemented this package, {@code null}
-* vendor or company that provided this implementation.
+* is returned if it is not known.
-* @return the vendor that implemented this package..
+* @return the vendor that implemented this package, {@code null}
+* is returned if it is not known.
 */
 public String getImplementationVendor() {
-return implVendor;
+return versionInfo.implVendor;
 }
 /**
 * Returns true if this package is sealed.
 *
 * @return true if the package is sealed, false otherwise
 */
 public boolean isSealed() {
-return sealBase != null;
+return module().isNamed() || versionInfo.sealBase != null;
 }
 /**
 * Returns true if this package is sealed with respect to the specified
-* code source url.
+* code source {@code url}.
 *
-* @param url the code source url
+* @param url the code source URL
-* @return true if this package is sealed with respect to url
+* @return true if this package is sealed with respect to the given {@code url}
 */
 public boolean isSealed(URL url) {
+Objects.requireNonNull(url);
+URL sealBase = null;
+if (versionInfo != VersionInfo.NULL_VERSION_INFO) {
+sealBase = versionInfo.sealBase;
+} else {
+try {
+URI uri = location();
+sealBase = uri != null ? uri.toURL() : null;
+} catch (MalformedURLException e) {
+}
+}
 return url.equals(sealBase);
 }
 /**
 * Compare this package's specification version with a
 *
 * @param desired the version string of the desired version.
 * @return true if this package's version number is greater
 *          than or equal to the desired version number
 *
-* @exception NumberFormatException if the desired or current version
+* @exception NumberFormatException if the current version is not known or
-*          is not of the correct dotted form.
+*          the desired or current version is not of the correct dotted form.
 */
 public boolean isCompatibleWith(String desired)
 throws NumberFormatException
 {
-if (specVersion == null || specVersion.length() < 1) {
+if (versionInfo.specVersion == null || versionInfo.specVersion.length() < 1) {
 throw new NumberFormatException("Empty version string");
 }
-String [] sa = specVersion.split("\\.", -1);
+String [] sa = versionInfo.specVersion.split("\\.", -1);
 int [] si = new int[sa.length];
 for (int i = 0; i < sa.length; i++) {
 si[i] = Integer.parseInt(sa[i]);
 if (si[i] < 0)
 throw NumberFormatException.forInputString("" + si[i]);
 }
 return true;
 }
 /**
-* Find a package by name in the callers {@code ClassLoader} instance.
+* Finds a package by name in the caller's class loader and its
-* The callers {@code ClassLoader} instance is used to find the package
+* ancestors.
-* instance corresponding to the named class. If the callers
+* <p>
-* {@code ClassLoader} instance is null then the set of packages loaded
+* If the caller's class loader defines a {@code Package} of the given name,
-* by the system {@code ClassLoader} instance is searched to find the
+* the {@code Package} is returned. Otherwise, the ancestors of the
-* named package. <p>
+* caller's class loader are searched recursively (parent by parent)
-*
+* for a {@code Package} of the given name.
-* Packages have attributes for versions and specifications only if the class
+* <p>
-* loader created the package instance with the appropriate attributes. Typically,
+* Calling this method is equivalent to calling {@link ClassLoader#getPackage}
-* those attributes are defined in the manifests that accompany the classes.
+* on a {@code ClassLoader} instance which is the caller's class loader.
 *
-* @param name a package name, for example, java.lang.
+* @param name A package name, such as "{@code java.lang}".
-* @return the package of the requested name. It may be null if no package
+* @return The {@code Package} of the given name defined by the caller's
-*          information is available from the archive or codebase.
+*         class loader or its ancestors, or {@code null} if not found.
+*
+* @deprecated
+* If multiple class loaders delegate to each other and define classes
+* with the same package name, and one such loader relies on the lookup
+* behavior of {@code getPackage} to return a {@code Package} from
+* a parent loader, then the properties exposed by the {@code Package}
+* may not be as expected in the rest of the program.
+* For example, the {@code Package} will only expose annotations from the
+* {@code package-info.class} file defined by the parent loader, even if
+* annotations exist in a {@code package-info.class} file defined by
+* a child loader.  A more robust approach is to use the
+* {@link ClassLoader#getDefinedPackage} method which returns
+* a {@code Package} for the specified class loader.
+*
+* @see ClassLoader#getDefinedPackage
 */
 @CallerSensitive
+@Deprecated
+@SuppressWarnings("deprecation")
 public static Package getPackage(String name) {
 ClassLoader l = ClassLoader.getClassLoader(Reflection.getCallerClass());
-if (l != null) {
+return l != null ? l.getPackage(name) : BootLoader.getDefinedPackage(name);
-return l.getPackage(name);
+}
-} else {
-return getSystemPackage(name);
+/**
-}
+* Returns all of the {@code Package}s defined by the caller's class loader
-}
+* and its ancestors.  The returned array may contain more than one
+* {@code Package} object of the same package name, each defined by
-/**
+* a different class loader in the class loader hierarchy.
-* Get all the packages currently known for the caller's {@code ClassLoader}
+* <p>
-* instance.  Those packages correspond to classes loaded via or accessible by
+* Calling this method is equivalent to calling {@link ClassLoader#getPackages}
-* name to that {@code ClassLoader} instance.  If the caller's
+* on a {@code ClassLoader} instance which is the caller's class loader.
-* {@code ClassLoader} instance is the bootstrap {@code ClassLoader}
+*
-* instance, which may be represented by {@code null} in some implementations,
+* @return  The array of {@code Package} objects defined by this
-* only packages corresponding to classes loaded by the bootstrap
+*          class loader and its ancestors
-* {@code ClassLoader} instance will be returned.
+*
-*
+* @see ClassLoader#getDefinedPackages
-* @return a new array of packages known to the callers {@code ClassLoader}
-* instance.  An zero length array is returned if none are known.
 */
 @CallerSensitive
 public static Package[] getPackages() {
-ClassLoader l = ClassLoader.getClassLoader(Reflection.getCallerClass());
+ClassLoader cl = ClassLoader.getClassLoader(Reflection.getCallerClass());
-if (l != null) {
+return cl != null ? cl.getPackages() : BootLoader.packages().toArray(Package[]::new);
-return l.getPackages();
-} else {
-return getSystemPackages();
-}
-}
-/**
-* Get the package for the specified class.
-* The class's class loader is used to find the package instance
-* corresponding to the specified class. If the class loader
-* is the bootstrap class loader, which may be represented by
-* {@code null} in some implementations, then the set of packages
-* loaded by the bootstrap class loader is searched to find the package.
-* <p>
-* Packages have attributes for versions and specifications only
-* if the class loader created the package
-* instance with the appropriate attributes. Typically those
-* attributes are defined in the manifests that accompany
-* the classes.
-*
-* @param c the class to get the package of.
-* @return the package of the class. It may be null if no package
-*          information is available from the archive or codebase.  */
-static Package getPackage(Class<?> c) {
-String name = c.getName();
-int i = name.lastIndexOf('.');
-if (i != -1) {
-name = name.substring(0, i);
-ClassLoader cl = c.getClassLoader();
-if (cl != null) {
-return cl.getPackage(name);
-} else {
-return getSystemPackage(name);
-}
-} else {
-return null;
-}
 }
 /**
 * Return the hash code computed from the package name.
 * @return the hash code computed from the package name.
 */
+@Override
 public int hashCode(){
-return pkgName.hashCode();
+return packageName().hashCode();
 }
 /**
 * Returns the string representation of this Package.
 * Its value is the string "package " and the package name.
 * If the package title is defined it is appended.
 * If the package version is defined it is appended.
 * @return the string representation of the package.
 */
+@Override
 public String toString() {
-String spec = specTitle;
+String spec = versionInfo.specTitle;
-String ver =  specVersion;
+String ver =  versionInfo.specVersion;
 if (spec != null && spec.length() > 0)
 spec = ", " + spec;
 else
 spec = "";
 if (ver != null && ver.length() > 0)
 ver = ", version " + ver;
 else
 ver = "";
-return "package " + pkgName + spec + ver;
+return "package " + packageName() + spec + ver;
 }
 private Class<?> getPackageInfo() {
 if (packageInfo == null) {
-try {
+// find package-info.class defined by loader
-packageInfo = Class.forName(pkgName + ".package-info", false, loader);
+String cn = packageName() + ".package-info";
-} catch (ClassNotFoundException ex) {
+PrivilegedAction<ClassLoader> pa = module()::getClassLoader;
+ClassLoader loader = AccessController.doPrivileged(pa);
+Class<?> c = loader != null ? loader.loadLocalClass(cn)
+: BootLoader.loadClassOrNull(cn);
+if (c != null) {
+packageInfo = c;
+} else {
 // store a proxy for the package info that has no annotations
 class PackageInfoProxy {}
 packageInfo = PackageInfoProxy.class;
 }
 }
 public Annotation[] getDeclaredAnnotations()  {
 return getPackageInfo().getDeclaredAnnotations();
 }
 /**
-* Construct a package instance with the specified version
+* Construct a package instance for an unnamed module
-* information.
+* with the specified version information.
+*
+* @apiNote
+* This method should not be called to define a Package for named module.
+*
 * @param name the name of the package
 * @param spectitle the title of the specification
 * @param specversion the version of the specification
 * @param specvendor the organization that maintains the specification
 * @param impltitle the title of the implementation
 * @param implversion the version of the implementation
 * @param implvendor the organization that maintains the implementation
+* @param sealbase code source where this Package comes from
+* @param loader defining class loader
 */
 Package(String name,
 String spectitle, String specversion, String specvendor,
 String impltitle, String implversion, String implvendor,
 URL sealbase, ClassLoader loader)
 {
-pkgName = name;
+super(Objects.requireNonNull(name),
-implTitle = impltitle;
+loader != null ? loader.getUnnamedModule()
-implVersion = implversion;
+: BootLoader.getUnnamedModule());
-implVendor = implvendor;
-specTitle = spectitle;
+this.versionInfo = VersionInfo.getInstance(spectitle, specversion,
-specVersion = specversion;
+specvendor, impltitle,
-specVendor = specvendor;
+implversion, implvendor,
-sealBase = sealbase;
+sealbase);
-this.loader = loader;
+}
+Package(String name, Module module) {
+super(name, module);
+this.versionInfo = VersionInfo.NULL_VERSION_INFO;
 }
 /*
-* Construct a package using the attributes from the specified manifest.
+* Versioning information.  Only for packages in unnamed modules.
-*
+*/
-* @param name the package name
+static class VersionInfo {
-* @param man the optional manifest for the package
+static final VersionInfo NULL_VERSION_INFO
-* @param url the optional code source url for the package
+= new VersionInfo(null, null, null, null, null, null, null);
-*/
-private Package(String name, Manifest man, URL url, ClassLoader loader) {
+private final String specTitle;
-String path = name.replace('.', '/').concat("/");
+private final String specVersion;
-String sealed = null;
+private final String specVendor;
-String specTitle= null;
+private final String implTitle;
-String specVersion= null;
+private final String implVersion;
-String specVendor= null;
+private final String implVendor;
-String implTitle= null;
+private final URL sealBase;
-String implVersion= null;
-String implVendor= null;
+static VersionInfo getInstance(String spectitle, String specversion,
-URL sealBase= null;
+String specvendor, String impltitle,
-Attributes attr = man.getAttributes(path);
+String implversion, String implvendor,
-if (attr != null) {
+URL sealbase) {
-specTitle   = attr.getValue(Name.SPECIFICATION_TITLE);
+if (spectitle == null && specversion == null &&
-specVersion = attr.getValue(Name.SPECIFICATION_VERSION);
+specvendor == null && impltitle == null &&
-specVendor  = attr.getValue(Name.SPECIFICATION_VENDOR);
+implvendor == null && sealbase == null) {
-implTitle   = attr.getValue(Name.IMPLEMENTATION_TITLE);
+return NULL_VERSION_INFO;
-implVersion = attr.getValue(Name.IMPLEMENTATION_VERSION);
-implVendor  = attr.getValue(Name.IMPLEMENTATION_VENDOR);
-sealed      = attr.getValue(Name.SEALED);
-}
-attr = man.getMainAttributes();
-if (attr != null) {
-if (specTitle == null) {
-specTitle = attr.getValue(Name.SPECIFICATION_TITLE);
 }
-if (specVersion == null) {
+return new VersionInfo(spectitle, specversion, specvendor,
-specVersion = attr.getValue(Name.SPECIFICATION_VERSION);
+impltitle, implversion, implvendor,
-}
+sealbase);
-if (specVendor == null) {
+}
-specVendor = attr.getValue(Name.SPECIFICATION_VENDOR);
-}
+private VersionInfo(String spectitle, String specversion,
-if (implTitle == null) {
+String specvendor, String impltitle,
-implTitle = attr.getValue(Name.IMPLEMENTATION_TITLE);
+String implversion, String implvendor,
-}
+URL sealbase)
-if (implVersion == null) {
+{
-implVersion = attr.getValue(Name.IMPLEMENTATION_VERSION);
+this.implTitle = impltitle;
-}
+this.implVersion = implversion;
-if (implVendor == null) {
+this.implVendor = implvendor;
-implVendor = attr.getValue(Name.IMPLEMENTATION_VENDOR);
+this.specTitle = spectitle;
-}
+this.specVersion = specversion;
-if (sealed == null) {
+this.specVendor = specvendor;
-sealed = attr.getValue(Name.SEALED);
+this.sealBase = sealbase;
 }
 }
-if ("true".equalsIgnoreCase(sealed)) {
-sealBase = url;
+private final VersionInfo versionInfo;
-}
+private Class<?> packageInfo;
-pkgName = name;
-this.specTitle = specTitle;
-this.specVersion = specVersion;
-this.specVendor = specVendor;
-this.implTitle = implTitle;
-this.implVersion = implVersion;
-this.implVendor = implVendor;
-this.sealBase = sealBase;
-this.loader = loader;
-}
-/*
-* Returns the loaded system package for the specified name.
-*/
-static Package getSystemPackage(String name) {
-Package pkg = pkgs.get(name);
-if (pkg == null) {
-name = name.replace('.', '/').concat("/");
-String fn = getSystemPackage0(name);
-if (fn != null) {
-pkg = defineSystemPackage(name, fn);
-}
-}
-return pkg;
-}
-/*
-* Return an array of loaded system packages.
-*/
-static Package[] getSystemPackages() {
-// First, update the system package map with new package names
-String[] names = getSystemPackages0();
-for (String name : names) {
-if (!pkgs.containsKey(name)) {
-defineSystemPackage(name, getSystemPackage0(name));
-}
-}
-return pkgs.values().toArray(new Package[pkgs.size()]);
-}
-private static Package defineSystemPackage(final String iname,
-final String fn)
-{
-// Convert to "."-separated package name
-String name = iname.substring(0, iname.length() - 1).replace('/', '.');
-// Creates a cached manifest for the file name, allowing
-// only-once, lazy reads of manifest from jar files
-CachedManifest cachedManifest = createCachedManifest(fn);
-pkgs.putIfAbsent(name, new Package(name, cachedManifest.getManifest(),
-cachedManifest.getURL(), null));
-// Ensure we only expose one Package object
-return pkgs.get(name);
-}
-private static CachedManifest createCachedManifest(String fn) {
-if (!manifests.containsKey(fn)) {
-manifests.putIfAbsent(fn, new CachedManifest(fn));
-}
-return manifests.get(fn);
-}
-// The map of loaded system packages
-private static final ConcurrentHashMap<String, Package> pkgs
-= new ConcurrentHashMap<>();
-// Maps each directory or zip file name to its corresponding manifest, if
-// it exists
-private static final ConcurrentHashMap<String, CachedManifest> manifests
-= new ConcurrentHashMap<>();
-private static class CachedManifest {
-private static final Manifest EMPTY_MANIFEST = new Manifest();
-private final String fileName;
-private final URL url;
-private volatile Manifest manifest;
-CachedManifest(final String fileName) {
-this.fileName = fileName;
-this.url = AccessController.doPrivileged(new PrivilegedAction<>() {
-public URL run() {
-final File file = new File(fileName);
-if (file.isFile()) {
-try {
-return ParseUtil.fileToEncodedURL(file);
-} catch (MalformedURLException e) {
-}
-}
-return null;
-}
-});
-}
-public URL getURL() {
-return url;
-}
-public Manifest getManifest() {
-if (url == null) {
-return EMPTY_MANIFEST;
-}
-Manifest m = manifest;
-if (m != null) {
-return m;
-}
-synchronized (this) {
-m = manifest;
-if (m != null) {
-return m;
-}
-m = AccessController.doPrivileged(new PrivilegedAction<>() {
-public Manifest run() {
-try (FileInputStream fis = new FileInputStream(fileName);
-JarInputStream jis = new JarInputStream(fis, false)) {
-return jis.getManifest();
-} catch (IOException e) {
-return null;
-}
-}
-});
-manifest = m = (m == null ? EMPTY_MANIFEST : m);
-}
-return m;
-}
-}
-private static native String getSystemPackage0(String name);
-private static native String[] getSystemPackages0();
-/*
-* Private storage for the package name and attributes.
-*/
-private final String pkgName;
-private final String specTitle;
-private final String specVersion;
-private final String specVendor;
-private final String implTitle;
-private final String implVersion;
-private final String implVendor;
-private final URL sealBase;
-private final transient ClassLoader loader;
-private transient Class<?> packageInfo;
 }

changeset 36511	9d0388c6b336
parent 32649	2ee9017c7597
child 37363	329dba26ffd2