| Methods Summary |
|---|
| private static java.lang.Package | defineSystemPackage(java.lang.String iname, java.lang.String fn)
return (Package) AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
String name = iname;
// Get the cached code source url for the file name
URL 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 = (Manifest)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;
}
});
|
| public A | getAnnotation(java.lang.Class annotationClass)
return getPackageInfo().getAnnotation(annotationClass);
|
| public java.lang.annotation.Annotation[] | getAnnotations()
return getPackageInfo().getAnnotations();
|
| public java.lang.annotation.Annotation[] | getDeclaredAnnotations()
return getPackageInfo().getDeclaredAnnotations();
|
| public java.lang.String | getImplementationTitle()Return the title of this package.
return implTitle;
|
| public java.lang.String | getImplementationVendor()Returns the name of the organization,
vendor or company that provided this implementation.
return implVendor;
|
| public java.lang.String | getImplementationVersion()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 implVersion;
|
| public java.lang.String | getName()Return the name of this package.
return pkgName;
|
| public static java.lang.Package | getPackage(java.lang.String name)Find a package by name in the callers ClassLoader instance.
The callers ClassLoader instance is used to find the package
instance corresponding to the named class. If the callers
ClassLoader instance is null then the set of packages loaded
by the system ClassLoader instance is searched to find the
named package.
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.
ClassLoader l = ClassLoader.getCallerClassLoader();
if (l != null) {
return l.getPackage(name);
} else {
return getSystemPackage(name);
}
|
| static java.lang.Package | getPackage(java.lang.Class c)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
null in some implementations, then the set of packages
loaded by the bootstrap class loader is searched to find the package.
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.
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;
}
|
| private java.lang.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;
|
| public static java.lang.Package[] | getPackages()Get all the packages currently known for the caller's ClassLoader
instance. Those packages correspond to classes loaded via or accessible by
name to that ClassLoader instance. If the caller's
ClassLoader instance is the bootstrap ClassLoader
instance, which may be represented by null in some implementations,
only packages corresponding to classes loaded by the bootstrap
ClassLoader instance will be returned.
ClassLoader l = ClassLoader.getCallerClassLoader();
if (l != null) {
return l.getPackages();
} else {
return getSystemPackages();
}
|
| public java.lang.String | getSpecificationTitle()Return the title of the specification that this package implements.
return specTitle;
|
| public java.lang.String | getSpecificationVendor()Return the name of the organization, vendor,
or company that owns and maintains the specification
of the classes that implement this package.
return specVendor;
|
| public java.lang.String | getSpecificationVersion()Returns the version number of the specification
that this package implements.
This version string must be a sequence of positive decimal
integers separated by "."'s and may have leading zeros.
When version strings are compared the most significant
numbers are compared.
return specVersion;
|
| static java.lang.Package | getSystemPackage(java.lang.String name)
synchronized (pkgs) {
Package pkg = (Package)pkgs.get(name);
if (pkg == null) {
name = name.replace('.", '/").concat("/");
String fn = getSystemPackage0(name);
if (fn != null) {
pkg = defineSystemPackage(name, fn);
}
}
return pkg;
}
|
| private static native java.lang.String | getSystemPackage0(java.lang.String name)
|
| static java.lang.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 (Package[])pkgs.values().toArray(new Package[pkgs.size()]);
}
|
| private static native java.lang.String[] | getSystemPackages0()
|
| public int | hashCode()Return the hash code computed from the package name.
return pkgName.hashCode();
|
| public boolean | isAnnotationPresent(java.lang.Class annotationClass)
return getPackageInfo().isAnnotationPresent(annotationClass);
|
| public boolean | isCompatibleWith(java.lang.String desired)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.
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.
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;
|
| public boolean | isSealed()Returns true if this package is sealed.
return sealBase != null;
|
| public boolean | isSealed(java.net.URL url)Returns true if this package is sealed with respect to the specified
code source url.
return url.equals(sealBase);
|
| private static java.util.jar.Manifest | loadManifest(java.lang.String fn)
try {
FileInputStream fis = new FileInputStream(fn);
JarInputStream jis = new JarInputStream(fis, false);
Manifest man = jis.getManifest();
jis.close();
return man;
} catch (IOException e) {
return null;
}
|
| public java.lang.String | toString()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.
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;
|
