616 lines
22 KiB
Java
616 lines
22 KiB
Java
|
/*
|
||
|
|
* Copyright (c) 1997, 2011, 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
|
||
|
|
* particular file as subject to the "Classpath" exception as provided
|
||
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
||
|
|
*
|
||
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
||
|
|
* accompanied this code).
|
||
|
|
*
|
||
|
|
* You should have received a copy of the GNU General Public License version
|
||
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
||
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||
|
|
*
|
||
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||
|
|
* or visit www.oracle.com if you need additional information or have any
|
||
|
|
* questions.
|
||
|
|
*/
|
||
|
|
|
||
|
|
package java.lang;
|
||
|
|
|
||
|
|
import java.io.InputStream;
|
||
|
|
import java.util.Enumeration;
|
||
|
|
|
||
|
|
import java.util.StringTokenizer;
|
||
|
|
import java.io.File;
|
||
|
|
import java.io.FileInputStream;
|
||
|
|
import java.io.FileNotFoundException;
|
||
|
|
import java.io.IOException;
|
||
|
|
import java.net.URL;
|
||
|
|
import java.net.MalformedURLException;
|
||
|
|
import java.security.AccessController;
|
||
|
|
import java.security.PrivilegedAction;
|
||
|
|
|
||
|
|
import java.util.jar.JarInputStream;
|
||
|
|
import java.util.jar.Manifest;
|
||
|
|
import java.util.jar.Attributes;
|
||
|
|
import java.util.jar.Attributes.Name;
|
||
|
|
import java.util.jar.JarException;
|
||
|
|
import java.util.Map;
|
||
|
|
import java.util.HashMap;
|
||
|
|
import java.util.Iterator;
|
||
|
|
|
||
|
|
import java.lang.annotation.Annotation;
|
||
|
|
import sun.net.www.ParseUtil;
|
||
|
|
import sun.reflect.CallerSensitive;
|
||
|
|
import sun.reflect.Reflection;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* {@code Package} objects contain version information
|
||
|
|
* about the implementation and specification of a Java package.
|
||
|
|
* This versioning information is retrieved and made available
|
||
|
|
* by the {@link ClassLoader} instance that
|
||
|
|
* loaded the class(es). Typically, it is stored in the manifest that is
|
||
|
|
* distributed with the classes.
|
||
|
|
*
|
||
|
|
* <p>The set of classes that make up the package may implement a
|
||
|
|
* particular specification and if so the specification title, version number,
|
||
|
|
* and vendor strings identify that specification.
|
||
|
|
* An application can ask if the package is
|
||
|
|
* compatible with a particular version, see the {@link
|
||
|
|
* #isCompatibleWith isCompatibleWith}
|
||
|
|
* method for details.
|
||
|
|
*
|
||
|
|
* <p>Specification version numbers use a syntax that consists of nonnegative
|
||
|
|
* 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:
|
||
|
|
* <dd>Digits RefinedVersion<sub>opt</sub></i>
|
||
|
|
|
||
|
|
* <p><dt><i>RefinedVersion:</i>
|
||
|
|
* <dd>{@code .} <i>Digits</i>
|
||
|
|
* <dd>{@code .} <i>Digits RefinedVersion</i>
|
||
|
|
*
|
||
|
|
* <p><dt><i>Digits:
|
||
|
|
* <dd>Digit
|
||
|
|
* <dd>Digits</i>
|
||
|
|
*
|
||
|
|
* <p><dt><i>Digit:</i>
|
||
|
|
* <dd>any character for which {@link Character#isDigit} returns {@code true},
|
||
|
|
* e.g. 0, 1, 2, ...
|
||
|
|
* </dl>
|
||
|
|
* </blockquote>
|
||
|
|
*
|
||
|
|
* <p>The implementation title, version, and vendor strings identify an
|
||
|
|
* implementation and are made available conveniently to enable accurate
|
||
|
|
* reporting of the packages involved when a problem occurs. The contents
|
||
|
|
* all three implementation strings are vendor specific. The
|
||
|
|
* implementation version strings have no specified syntax and should
|
||
|
|
* only be compared for equality with desired version identifiers.
|
||
|
|
*
|
||
|
|
* <p>Within each {@code ClassLoader} instance all classes from the same
|
||
|
|
* java package have the same Package object. The static methods allow a package
|
||
|
|
* to be found by name or the set of all packages known to the current class
|
||
|
|
* loader to be found.
|
||
|
|
*
|
||
|
|
* @see ClassLoader#definePackage
|
||
|
|
*/
|
||
|
|
public class Package 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™ Language Specification</cite>,
|
||
|
|
* for example, {@code java.lang}
|
||
|
|
*/
|
||
|
|
public String getName() {
|
||
|
|
return pkgName;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Return the title of the specification that this package implements.
|
||
|
|
* @return the specification title, null is returned if it is not known.
|
||
|
|
*/
|
||
|
|
public String getSpecificationTitle() {
|
||
|
|
return specTitle;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the version number of the specification
|
||
|
|
* that this package implements.
|
||
|
|
* This version string must be a sequence of nonnegative 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.
|
||
|
|
*/
|
||
|
|
public String getSpecificationVersion() {
|
||
|
|
return 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.
|
||
|
|
*/
|
||
|
|
public String getSpecificationVendor() {
|
||
|
|
return specVendor;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Return the title of this package.
|
||
|
|
* @return the title of the implementation, null is returned if it is not known.
|
||
|
|
*/
|
||
|
|
public String getImplementationTitle() {
|
||
|
|
return 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.
|
||
|
|
*/
|
||
|
|
public String getImplementationVersion() {
|
||
|
|
return implVersion;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the name of the organization,
|
||
|
|
* vendor or company that provided this implementation.
|
||
|
|
* @return the vendor that implemented this package..
|
||
|
|
*/
|
||
|
|
public String getImplementationVendor() {
|
||
|
|
return implVendor;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns true if this package is sealed.
|
||
|
|
*
|
||
|
|
* @return true if the package is sealed, false otherwise
|
||
|
|
*/
|
||
|
|
public boolean isSealed() {
|
||
|
|
return sealBase != null;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns true if this package is sealed with respect to the specified
|
||
|
|
* code source url.
|
||
|
|
*
|
||
|
|
* @param url the code source url
|
||
|
|
* @return true if this package is sealed with respect to url
|
||
|
|
*/
|
||
|
|
public boolean isSealed(URL url) {
|
||
|
|
return url.equals(sealBase);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Compare this package's specification version with a
|
||
|
|
* desired version. It returns true if
|
||
|
|
* this packages specification version number is greater than or equal
|
||
|
|
* to the desired version number. <p>
|
||
|
|
*
|
||
|
|
* Version numbers are compared by sequentially comparing corresponding
|
||
|
|
* components of the desired and specification strings.
|
||
|
|
* Each component is converted as a decimal integer and the values
|
||
|
|
* compared.
|
||
|
|
* If the specification value is greater than the desired
|
||
|
|
* value true is returned. If the value is less false is returned.
|
||
|
|
* If the values are equal the period is skipped and the next pair of
|
||
|
|
* components is compared.
|
||
|
|
*
|
||
|
|
* @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
|
||
|
|
* is not of the correct dotted form.
|
||
|
|
*/
|
||
|
|
public boolean isCompatibleWith(String desired)
|
||
|
|
throws NumberFormatException
|
||
|
|
{
|
||
|
|
if (specVersion == null || specVersion.length() < 1) {
|
||
|
|
throw new NumberFormatException("Empty version string");
|
||
|
|
}
|
||
|
|
|
||
|
|
String [] sa = 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]);
|
||
|
|
}
|
||
|
|
|
||
|
|
String [] da = desired.split("\\.", -1);
|
||
|
|
int [] di = new int[da.length];
|
||
|
|
for (int i = 0; i < da.length; i++) {
|
||
|
|
di[i] = Integer.parseInt(da[i]);
|
||
|
|
if (di[i] < 0)
|
||
|
|
throw NumberFormatException.forInputString("" + di[i]);
|
||
|
|
}
|
||
|
|
|
||
|
|
int len = Math.max(di.length, si.length);
|
||
|
|
for (int i = 0; i < len; i++) {
|
||
|
|
int d = (i < di.length ? di[i] : 0);
|
||
|
|
int s = (i < si.length ? si[i] : 0);
|
||
|
|
if (s < d)
|
||
|
|
return false;
|
||
|
|
if (s > d)
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Find a package by name in the callers {@code ClassLoader} instance.
|
||
|
|
* The callers {@code ClassLoader} instance is used to find the package
|
||
|
|
* instance corresponding to the named class. If the callers
|
||
|
|
* {@code ClassLoader} instance is null then the set of packages loaded
|
||
|
|
* by the system {@code ClassLoader} instance is searched to find the
|
||
|
|
* named 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 name a package name, for example, java.lang.
|
||
|
|
* @return the package of the requested name. It may be null if no package
|
||
|
|
* information is available from the archive or codebase.
|
||
|
|
*/
|
||
|
|
@CallerSensitive
|
||
|
|
public static Package getPackage(String name) {
|
||
|
|
ClassLoader l = ClassLoader.getClassLoader(Reflection.getCallerClass());
|
||
|
|
if (l != null) {
|
||
|
|
return l.getPackage(name);
|
||
|
|
} else {
|
||
|
|
return getSystemPackage(name);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get all the packages currently known for the caller's {@code ClassLoader}
|
||
|
|
* instance. Those packages correspond to classes loaded via or accessible by
|
||
|
|
* name to that {@code ClassLoader} instance. If the caller's
|
||
|
|
* {@code ClassLoader} instance is the bootstrap {@code ClassLoader}
|
||
|
|
* instance, which may be represented by {@code null} in some implementations,
|
||
|
|
* only packages corresponding to classes loaded by the bootstrap
|
||
|
|
* {@code ClassLoader} instance will be returned.
|
||
|
|
*
|
||
|
|
* @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());
|
||
|
|
if (l != null) {
|
||
|
|
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 class 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.
|
||
|
|
*/
|
||
|
|
public int hashCode(){
|
||
|
|
return pkgName.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.
|
||
|
|
*/
|
||
|
|
public String toString() {
|
||
|
|
String spec = specTitle;
|
||
|
|
String ver = 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;
|
||
|
|
}
|
||
|
|
|
||
|
|
private Class<?> getPackageInfo() {
|
||
|
|
if (packageInfo == null) {
|
||
|
|
try {
|
||
|
|
packageInfo = Class.forName(pkgName + ".package-info", false, loader);
|
||
|
|
} catch (ClassNotFoundException ex) {
|
||
|
|
// store a proxy for the package info that has no annotations
|
||
|
|
class PackageInfoProxy {}
|
||
|
|
packageInfo = PackageInfoProxy.class;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return packageInfo;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @throws NullPointerException {@inheritDoc}
|
||
|
|
* @since 1.5
|
||
|
|
*/
|
||
|
|
public <A extends Annotation> A getAnnotation(Class<A> annotationClass) {
|
||
|
|
return getPackageInfo().getAnnotation(annotationClass);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @throws NullPointerException {@inheritDoc}
|
||
|
|
* @since 1.5
|
||
|
|
*/
|
||
|
|
public boolean isAnnotationPresent(
|
||
|
|
Class<? extends Annotation> annotationClass) {
|
||
|
|
return getPackageInfo().isAnnotationPresent(annotationClass);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @since 1.5
|
||
|
|
*/
|
||
|
|
public Annotation[] getAnnotations() {
|
||
|
|
return getPackageInfo().getAnnotations();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @since 1.5
|
||
|
|
*/
|
||
|
|
public Annotation[] getDeclaredAnnotations() {
|
||
|
|
return getPackageInfo().getDeclaredAnnotations();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Construct a package instance with the specified version
|
||
|
|
* information.
|
||
|
|
* @param pkgName 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
|
||
|
|
* @return a new package for containing the specified information.
|
||
|
|
*/
|
||
|
|
Package(String name,
|
||
|
|
String spectitle, String specversion, String specvendor,
|
||
|
|
String impltitle, String implversion, String implvendor,
|
||
|
|
URL sealbase, ClassLoader loader)
|
||
|
|
{
|
||
|
|
pkgName = name;
|
||
|
|
implTitle = impltitle;
|
||
|
|
implVersion = implversion;
|
||
|
|
implVendor = implvendor;
|
||
|
|
specTitle = spectitle;
|
||
|
|
specVersion = specversion;
|
||
|
|
specVendor = specvendor;
|
||
|
|
sealBase = sealbase;
|
||
|
|
this.loader = loader;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Construct a package using the attributes from the specified manifest.
|
||
|
|
*
|
||
|
|
* @param name the package name
|
||
|
|
* @param man the optional manifest for the package
|
||
|
|
* @param url the optional code source url for the package
|
||
|
|
*/
|
||
|
|
private Package(String name, Manifest man, URL url, ClassLoader loader) {
|
||
|
|
String path = name.replace('.', '/').concat("/");
|
||
|
|
String sealed = null;
|
||
|
|
String specTitle= null;
|
||
|
|
String specVersion= null;
|
||
|
|
String specVendor= null;
|
||
|
|
String implTitle= null;
|
||
|
|
String implVersion= null;
|
||
|
|
String implVendor= null;
|
||
|
|
URL sealBase= null;
|
||
|
|
Attributes attr = man.getAttributes(path);
|
||
|
|
if (attr != null) {
|
||
|
|
specTitle = attr.getValue(Name.SPECIFICATION_TITLE);
|
||
|
|
specVersion = attr.getValue(Name.SPECIFICATION_VERSION);
|
||
|
|
specVendor = attr.getValue(Name.SPECIFICATION_VENDOR);
|
||
|
|
implTitle = attr.getValue(Name.IMPLEMENTATION_TITLE);
|
||
|
|
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) {
|
||
|
|
specVersion = attr.getValue(Name.SPECIFICATION_VERSION);
|
||
|
|
}
|
||
|
|
if (specVendor == null) {
|
||
|
|
specVendor = attr.getValue(Name.SPECIFICATION_VENDOR);
|
||
|
|
}
|
||
|
|
if (implTitle == null) {
|
||
|
|
implTitle = attr.getValue(Name.IMPLEMENTATION_TITLE);
|
||
|
|
}
|
||
|
|
if (implVersion == null) {
|
||
|
|
implVersion = attr.getValue(Name.IMPLEMENTATION_VERSION);
|
||
|
|
}
|
||
|
|
if (implVendor == null) {
|
||
|
|
implVendor = attr.getValue(Name.IMPLEMENTATION_VENDOR);
|
||
|
|
}
|
||
|
|
if (sealed == null) {
|
||
|
|
sealed = attr.getValue(Name.SEALED);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if ("true".equalsIgnoreCase(sealed)) {
|
||
|
|
sealBase = url;
|
||
|
|
}
|
||
|
|
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) {
|
||
|
|
synchronized (pkgs) {
|
||
|
|
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();
|
||
|
|
synchronized (pkgs) {
|
||
|
|
for (int i = 0; i < names.length; i++) {
|
||
|
|
defineSystemPackage(names[i], getSystemPackage0(names[i]));
|
||
|
|
}
|
||
|
|
return pkgs.values().toArray(new Package[pkgs.size()]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static Package defineSystemPackage(final String iname,
|
||
|
|
final String fn)
|
||
|
|
{
|
||
|
|
return AccessController.doPrivileged(new PrivilegedAction<Package>() {
|
||
|
|
public Package run() {
|
||
|
|
String name = iname;
|
||
|
|
// Get the cached code source url for the file name
|
||
|
|
URL url = urls.get(fn);
|
||
|
|
if (url == null) {
|
||
|
|
// URL not found, so create one
|
||
|
|
File file = new File(fn);
|
||
|
|
try {
|
||
|
|
url = ParseUtil.fileToEncodedURL(file);
|
||
|
|
} catch (MalformedURLException e) {
|
||
|
|
}
|
||
|
|
if (url != null) {
|
||
|
|
urls.put(fn, url);
|
||
|
|
// If loading a JAR file, then also cache the manifest
|
||
|
|
if (file.isFile()) {
|
||
|
|
mans.put(fn, loadManifest(fn));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Convert to "."-separated package name
|
||
|
|
name = name.substring(0, name.length() - 1).replace('/', '.');
|
||
|
|
Package pkg;
|
||
|
|
Manifest man = mans.get(fn);
|
||
|
|
if (man != null) {
|
||
|
|
pkg = new Package(name, man, url, null);
|
||
|
|
} else {
|
||
|
|
pkg = new Package(name, null, null, null,
|
||
|
|
null, null, null, null, null);
|
||
|
|
}
|
||
|
|
pkgs.put(name, pkg);
|
||
|
|
return pkg;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Returns the Manifest for the specified JAR file name.
|
||
|
|
*/
|
||
|
|
private static Manifest loadManifest(String fn) {
|
||
|
|
try (FileInputStream fis = new FileInputStream(fn);
|
||
|
|
JarInputStream jis = new JarInputStream(fis, false))
|
||
|
|
{
|
||
|
|
return jis.getManifest();
|
||
|
|
} catch (IOException e) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// The map of loaded system packages
|
||
|
|
private static Map<String, Package> pkgs = new HashMap<>(31);
|
||
|
|
|
||
|
|
// Maps each directory or zip file name to its corresponding url
|
||
|
|
private static Map<String, URL> urls = new HashMap<>(10);
|
||
|
|
|
||
|
|
// Maps each code source url for a jar file to its manifest
|
||
|
|
private static Map<String, Manifest> mans = new HashMap<>(10);
|
||
|
|
|
||
|
|
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 transient final ClassLoader loader;
|
||
|
|
private transient Class packageInfo;
|
||
|
|
}
|