| /* |
| * Copyright (c) 1999, 2004, 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 sun.misc; |
| |
| import java.util.StringTokenizer; |
| import java.util.jar.Attributes; |
| import java.util.jar.Attributes.Name; |
| import java.util.ResourceBundle; |
| import java.util.MissingResourceException; |
| import java.text.MessageFormat; |
| import java.lang.Character.*; |
| |
| |
| /** |
| * This class holds all necessary information to install or |
| * upgrade a extension on the user's disk |
| * |
| * @author Jerome Dochez |
| */ |
| public class ExtensionInfo { |
| |
| /** |
| * <p> |
| * public static values returned by the isCompatible method |
| * </p> |
| */ |
| public static final int COMPATIBLE = 0; |
| public static final int REQUIRE_SPECIFICATION_UPGRADE = 1; |
| public static final int REQUIRE_IMPLEMENTATION_UPGRADE = 2; |
| public static final int REQUIRE_VENDOR_SWITCH = 3; |
| public static final int INCOMPATIBLE = 4; |
| |
| /** |
| * <p> |
| * attributes fully describer an extension. The underlying described |
| * extension may be installed and requested. |
| * <p> |
| */ |
| public String title; |
| public String name; |
| public String specVersion; |
| public String specVendor; |
| public String implementationVersion; |
| public String vendor; |
| public String vendorId; |
| public String url; |
| |
| // For I18N support |
| private static final ResourceBundle rb = |
| ResourceBundle.getBundle("sun.misc.resources.Messages"); |
| |
| |
| /** |
| * <p> |
| * Create a new uninitialized extension information object |
| * </p> |
| */ |
| public ExtensionInfo() { |
| } |
| |
| /** |
| * <p> |
| * Create and initialize an extension information object. |
| * The initialization uses the attributes passed as being |
| * the content of a manifest file to load the extension |
| * information from. |
| * Since manifest file may contain information on several |
| * extension they may depend on, the extension key parameter |
| * is prepanded to the attribute name to make the key used |
| * to retrieve the attribute from the manifest file |
| * <p> |
| * @param extensionKey unique extension key in the manifest |
| * @param attr Attributes of a manifest file |
| */ |
| public ExtensionInfo(String extensionKey, Attributes attr) |
| throws NullPointerException |
| { |
| String s; |
| if (extensionKey!=null) { |
| s = extensionKey + "-"; |
| } else { |
| s =""; |
| } |
| |
| String attrKey = s + Name.EXTENSION_NAME.toString(); |
| name = attr.getValue(attrKey); |
| if (name != null) |
| name = name.trim(); |
| |
| attrKey = s + Name.SPECIFICATION_TITLE.toString(); |
| title = attr.getValue(attrKey); |
| if (title != null) |
| title = title.trim(); |
| |
| attrKey = s + Name.SPECIFICATION_VERSION.toString(); |
| specVersion = attr.getValue(attrKey); |
| if (specVersion != null) |
| specVersion = specVersion.trim(); |
| |
| attrKey = s + Name.SPECIFICATION_VENDOR.toString(); |
| specVendor = attr.getValue(attrKey); |
| if (specVendor != null) |
| specVendor = specVendor.trim(); |
| |
| attrKey = s + Name.IMPLEMENTATION_VERSION.toString(); |
| implementationVersion = attr.getValue(attrKey); |
| if (implementationVersion != null) |
| implementationVersion = implementationVersion.trim(); |
| |
| attrKey = s + Name.IMPLEMENTATION_VENDOR.toString(); |
| vendor = attr.getValue(attrKey); |
| if (vendor != null) |
| vendor = vendor.trim(); |
| |
| attrKey = s + Name.IMPLEMENTATION_VENDOR_ID.toString(); |
| vendorId = attr.getValue(attrKey); |
| if (vendorId != null) |
| vendorId = vendorId.trim(); |
| |
| attrKey =s + Name.IMPLEMENTATION_URL.toString(); |
| url = attr.getValue(attrKey); |
| if (url != null) |
| url = url.trim(); |
| } |
| |
| /** |
| * <p> |
| * @return true if the extension described by this extension information |
| * is compatible with the extension described by the extension |
| * information passed as a parameter |
| * </p> |
| * |
| * @param the requested extension information to compare to |
| */ |
| public int isCompatibleWith(ExtensionInfo ei) { |
| |
| if (name == null || ei.name == null) |
| return INCOMPATIBLE; |
| if (name.compareTo(ei.name)==0) { |
| // is this true, if not spec version is specified, we consider |
| // the value as being "any". |
| if (specVersion == null || ei.specVersion == null) |
| return COMPATIBLE; |
| |
| int version = compareExtensionVersion(specVersion, ei.specVersion); |
| if (version<0) { |
| // this extension specification is "older" |
| if (vendorId != null && ei.vendorId !=null) { |
| if (vendorId.compareTo(ei.vendorId)!=0) { |
| return REQUIRE_VENDOR_SWITCH; |
| } |
| } |
| return REQUIRE_SPECIFICATION_UPGRADE; |
| } else { |
| // the extension spec is compatible, let's look at the |
| // implementation attributes |
| if (vendorId != null && ei.vendorId != null) { |
| // They care who provides the extension |
| if (vendorId.compareTo(ei.vendorId)!=0) { |
| // They want to use another vendor implementation |
| return REQUIRE_VENDOR_SWITCH; |
| } else { |
| // Vendor matches, let's see the implementation version |
| if (implementationVersion != null && ei.implementationVersion != null) { |
| // they care about the implementation version |
| version = compareExtensionVersion(implementationVersion, ei.implementationVersion); |
| if (version<0) { |
| // This extension is an older implementation |
| return REQUIRE_IMPLEMENTATION_UPGRADE; |
| } |
| } |
| } |
| } |
| // All othe cases, we consider the extensions to be compatible |
| return COMPATIBLE; |
| } |
| } |
| return INCOMPATIBLE; |
| } |
| |
| /** |
| * <p> |
| * helper method to print sensible information on the undelying described |
| * extension |
| * </p> |
| */ |
| public String toString() { |
| return "Extension : title(" + title + "), name(" + name + "), spec vendor(" + |
| specVendor + "), spec version(" + specVersion + "), impl vendor(" + |
| vendor + "), impl vendor id(" + vendorId + "), impl version(" + |
| implementationVersion + "), impl url(" + url + ")"; |
| } |
| |
| /* |
| * <p> |
| * helper method to compare two versions. |
| * version are in the x.y.z.t pattern. |
| * </p> |
| * @param source version to compare to |
| * @param target version used to compare against |
| * @return < 0 if source < version |
| * > 0 if source > version |
| * = 0 if source = version |
| */ |
| private int compareExtensionVersion(String source, String target) |
| throws NumberFormatException |
| { |
| source = source.toLowerCase(); |
| target = target.toLowerCase(); |
| |
| return strictCompareExtensionVersion(source, target); |
| } |
| |
| |
| /* |
| * <p> |
| * helper method to compare two versions. |
| * version are in the x.y.z.t pattern. |
| * </p> |
| * @param source version to compare to |
| * @param target version used to compare against |
| * @return < 0 if source < version |
| * > 0 if source > version |
| * = 0 if source = version |
| */ |
| private int strictCompareExtensionVersion(String source, String target) |
| throws NumberFormatException |
| { |
| if (source.equals(target)) |
| return 0; |
| |
| StringTokenizer stk = new StringTokenizer(source, ".,"); |
| StringTokenizer ttk = new StringTokenizer(target, ".,"); |
| |
| // Compare number |
| int n = 0, m = 0, result = 0; |
| |
| // Convert token into meaning number for comparision |
| if (stk.hasMoreTokens()) |
| n = convertToken(stk.nextToken().toString()); |
| |
| // Convert token into meaning number for comparision |
| if (ttk.hasMoreTokens()) |
| m = convertToken(ttk.nextToken().toString()); |
| |
| if (n > m) |
| return 1; |
| else if (m > n) |
| return -1; |
| else |
| { |
| // Look for index of "." in the string |
| int sIdx = source.indexOf("."); |
| int tIdx = target.indexOf("."); |
| |
| if (sIdx == -1) |
| sIdx = source.length() - 1; |
| |
| if (tIdx == -1) |
| tIdx = target.length() - 1; |
| |
| return strictCompareExtensionVersion(source.substring(sIdx + 1), |
| target.substring(tIdx + 1)); |
| } |
| } |
| |
| private int convertToken(String token) |
| { |
| if (token == null || token.equals("")) |
| return 0; |
| |
| int charValue = 0; |
| int charVersion = 0; |
| int patchVersion = 0; |
| int strLength = token.length(); |
| int endIndex = strLength; |
| char lastChar; |
| |
| Object[] args = {name}; |
| MessageFormat mf = new MessageFormat(rb.getString("optpkg.versionerror")); |
| String versionError = mf.format(args); |
| |
| // Look for "-" for pre-release |
| int prIndex = token.indexOf("-"); |
| |
| // Look for "_" for patch release |
| int patchIndex = token.indexOf("_"); |
| |
| if (prIndex == -1 && patchIndex == -1) |
| { |
| // This is a FCS release |
| try { |
| return Integer.parseInt(token) * 100; |
| } catch (NumberFormatException e) { |
| System.out.println(versionError); |
| return 0; |
| } |
| } |
| else if (patchIndex != -1) |
| { |
| // This is a patch (update) release |
| int prversion; |
| try { |
| // Obtain the version |
| prversion = Integer.parseInt(token.substring(0, patchIndex)); |
| |
| // Check to see if the patch version is in the n.n.n_nnl format (special release) |
| lastChar = token.charAt(strLength-1); |
| if (Character.isLetter(lastChar)) { |
| // letters a-z have values from 10-35 |
| charValue = Character.getNumericValue(lastChar); |
| endIndex = strLength-1; |
| |
| // Obtain the patch version id |
| patchVersion = Integer.parseInt(token.substring(patchIndex+1, endIndex)); |
| |
| if (charValue >= Character.getNumericValue('a') && charValue <= Character.getNumericValue('z')) { |
| // This is a special release |
| charVersion = (patchVersion * 100) + charValue; |
| } else { |
| // character is not a a-z letter, ignore |
| charVersion = 0; |
| System.out.println(versionError); |
| } |
| } else { |
| // This is a regular update release. Obtain the patch version id |
| patchVersion = Integer.parseInt(token.substring(patchIndex+1, endIndex)); |
| } |
| } catch (NumberFormatException e) { |
| System.out.println(versionError); |
| return 0; |
| } |
| return prversion * 100 + (patchVersion + charVersion); |
| } |
| else |
| { |
| //This is a milestone release, either a early access, alpha, beta, or RC |
| |
| // Obtain the version |
| int mrversion; |
| try { |
| mrversion = Integer.parseInt(token.substring(0, prIndex)); |
| } catch (NumberFormatException e) { |
| System.out.println(versionError); |
| return 0; |
| } |
| |
| // Obtain the patch version string, including the milestone + version |
| String prString = token.substring(prIndex + 1); |
| |
| // Milestone version |
| String msVersion = ""; |
| int delta = 0; |
| |
| if (prString.indexOf("ea") != -1) |
| { |
| msVersion = prString.substring(2); |
| delta = 50; |
| } |
| else if (prString.indexOf("alpha") != -1) |
| { |
| msVersion = prString.substring(5); |
| delta = 40; |
| } |
| else if (prString.indexOf("beta") != -1) |
| { |
| msVersion = prString.substring(4); |
| delta = 30; |
| } |
| else if (prString.indexOf("rc") != -1) |
| { |
| msVersion = prString.substring(2); |
| delta = 20; |
| } |
| |
| if (msVersion == null || msVersion.equals("")) |
| { |
| // No version after the milestone, assume 0 |
| return mrversion * 100 - delta ; |
| } |
| else |
| { |
| // Convert the milestone version |
| try { |
| return mrversion * 100 - delta + Integer.parseInt(msVersion); |
| } catch (NumberFormatException e) { |
| System.out.println(versionError); |
| return 0; |
| } |
| } |
| } |
| } |
| } |
