--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/demo/share/jpackager/JNLPConverter/src/jnlp/converter/parser/GeneralUtil.java Fri Oct 12 19:00:51 2018 -0400
@@ -0,0 +1,415 @@
+/*
+ * Copyright (c) 2006, 2018, 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.
+ *
+ * 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 jnlp.converter.parser;
+
+import java.util.Locale;
+import java.util.ArrayList;
+import java.util.StringTokenizer;
+import java.io.BufferedInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.net.URL;
+
+/**
+ * Handy class to add some utility methods for dealing with property matching
+ * etc.
+ */
+public class GeneralUtil {
+
+ public static boolean prefixMatchStringList(String[] prefixList, String target) {
+ // No prefixes matches everything
+ if (prefixList == null) {
+ return true;
+ }
+ // No target, but a prefix list does not match anything
+ if (target == null) {
+ return false;
+ }
+ for (String prefix : prefixList) {
+ if (target.startsWith(prefix)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private static String getOSArch() {
+ return System.getProperty("os.arch");
+ }
+
+ public static boolean prefixMatchArch(String[] prefixList) {
+ // No prefixes matches everything
+ if (prefixList == null) {
+ return true;
+ }
+
+ // check for the current arch
+ String arch = getOSArch();
+ for (String prefix : prefixList) {
+ if (arch.startsWith(prefix)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * Converts a space delimited string to a list of strings
+ */
+ public static String[] getStringList(String str) {
+ if (str == null) {
+ return null;
+ }
+ ArrayList<String> list = new ArrayList<>();
+ int i = 0;
+ int length = str.length();
+ StringBuffer sb = null;
+ while (i < length) {
+ char ch = str.charAt(i);
+ switch (ch) {
+ case ' ':
+ // A space was hit. Add string to list
+ if (sb != null) {
+ list.add(sb.toString());
+ sb = null;
+ }
+ break;
+ case '\\':
+ // It is a delimiter. Add next character
+ if (i + 1 < length) {
+ ch = str.charAt(++i);
+ if (sb == null) {
+ sb = new StringBuffer();
+ }
+ sb.append(ch);
+ }
+ break;
+ default:
+ if (sb == null) {
+ sb = new StringBuffer();
+ } sb.append(ch);
+ break;
+ }
+ i++; // Next character
+ }
+ // Make sure to add the last part to the list too
+ if (sb != null) {
+ list.add(sb.toString());
+ }
+ if (list.isEmpty()) {
+ return null;
+ }
+ String[] results = new String[list.size()];
+ return list.toArray(results);
+ }
+
+ /**
+ * Checks if string list matches default locale
+ */
+ public static boolean matchLocale(String[] localeList, Locale locale) {
+ // No locale specified matches everything
+ if (localeList == null) {
+ return true;
+ }
+ for (String localeList1 : localeList) {
+ if (matchLocale(localeList1, locale)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Checks if string matches default locale
+ */
+ public static boolean matchLocale(String localeStr, Locale locale) {
+ if (localeStr == null || localeStr.length() == 0) {
+ return true;
+ }
+
+ // Compare against default locale
+ String language;
+ String country;
+ String variant;
+
+ // The locale string is of the form language_country_variant
+ StringTokenizer st = new StringTokenizer(localeStr, "_", false);
+ if (st.hasMoreElements() && locale.getLanguage().length() > 0) {
+ language = st.nextToken();
+ if (!language.equalsIgnoreCase(locale.getLanguage())) {
+ return false;
+ }
+ }
+ if (st.hasMoreElements() && locale.getCountry().length() > 0) {
+ country = st.nextToken();
+ if (!country.equalsIgnoreCase(locale.getCountry())) {
+ return false;
+ }
+ }
+ if (st.hasMoreElements() && locale.getVariant().length() > 0) {
+ variant = st.nextToken();
+ if (!variant.equalsIgnoreCase(locale.getVariant())) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ public static long heapValToLong(String heapValue) {
+ if (heapValue == null) {
+ return -1;
+ }
+ long multiplier = 1;
+ if (heapValue.toLowerCase().lastIndexOf('m') != -1) {
+ // units are megabytes, 1 megabyte = 1024 * 1024 bytes
+ multiplier = 1024 * 1024;
+ heapValue = heapValue.substring(0, heapValue.length() - 1);
+ } else if (heapValue.toLowerCase().lastIndexOf('k') != -1) {
+ // units are kilobytes, 1 kilobyte = 1024 bytes
+ multiplier = 1024;
+ heapValue = heapValue.substring(0, heapValue.length() - 1);
+ }
+ long theValue;
+ try {
+ theValue = Long.parseLong(heapValue);
+ theValue = theValue * multiplier;
+ } catch (NumberFormatException e) {
+ theValue = -1;
+ }
+ return theValue;
+ }
+
+ public static byte[] readBytes(InputStream is, long size) throws IOException {
+ // Sanity on file size (restrict to 1M)
+ if (size > 1024 * 1024) {
+ throw new IOException("File too large");
+ }
+
+ BufferedInputStream bis;
+ if (is instanceof BufferedInputStream) {
+ bis = (BufferedInputStream) is;
+ } else {
+ bis = new BufferedInputStream(is);
+ }
+
+ if (size <= 0) {
+ size = 10 * 1024; // Default to 10K
+ }
+ byte[] b = new byte[(int) size];
+ int n;
+ int bytesRead = 0;
+ n = bis.read(b, bytesRead, b.length - bytesRead);
+ while (n != -1) {
+ bytesRead += n;
+ // Still room in array
+ if (b.length == bytesRead) {
+ byte[] bb = new byte[b.length * 2];
+ System.arraycopy(b, 0, bb, 0, b.length);
+ b = bb;
+ }
+ // Read next line
+ n = bis.read(b, bytesRead, b.length - bytesRead);
+ }
+ bis.close();
+ is.close();
+
+ if (bytesRead != b.length) {
+ byte[] bb = new byte[bytesRead];
+ System.arraycopy(b, 0, bb, 0, bytesRead);
+ b = bb;
+ }
+ return b;
+ }
+
+ public static String getOSFullName() {
+ return System.getProperty("os.name");
+ }
+
+ /**
+ * Makes sure a URL is a path URL, i.e., ends with '/'
+ */
+ public static URL asPathURL(URL url) {
+ if (url == null) {
+ return null;
+ }
+
+ String path = url.getFile();
+ if (path != null && !path.endsWith("/")) {
+ try {
+ return new URL(url.getProtocol(),
+ url.getHost(),
+ url.getPort(),
+ url.getFile() + "/");
+ } catch (MalformedURLException mue) {
+ // Should not happen
+ }
+ }
+ // Just return same URl
+ return url;
+ }
+
+ public static Locale getDefaultLocale() {
+ return Locale.getDefault();
+ }
+
+ public static String toNormalizedString(URL u) {
+ if (u == null) {
+ return "";
+ }
+
+ try {
+ if (u.getPort() == u.getDefaultPort()) {
+ u = new URL(u.getProtocol().toLowerCase(),
+ u.getHost().toLowerCase(), -1, u.getFile());
+ } else {
+ u = new URL(u.getProtocol().toLowerCase(),
+ u.getHost().toLowerCase(), u.getPort(), u.getFile());
+ }
+ } catch (MalformedURLException ex) {
+ }
+ return u.toExternalForm();
+ }
+
+ public static boolean sameURLs(URL u1, URL u2) {
+ if (u1 == null || u2 == null || (u1 == u2)) {
+ return (u1 == u2);
+ }
+ //NB: do not use URL.sameFile() as it will do DNS lookup
+ // Also, do quick check before slow string comparisons
+ String f1 = u1.getFile();
+ String f2 = u2.getFile();
+ return (f1.length() == f2.length()) && sameBase(u1, u2)
+ && f1.equalsIgnoreCase(f2);
+ }
+
+ public static boolean sameBase(URL u1, URL u2) {
+ return u1 != null && u2 != null &&
+ sameHost(u1, u2) && samePort(u1, u2) && sameProtocol(u1, u2);
+ }
+
+ private static boolean sameProtocol(URL u1, URL u2) {
+ //protocols are known to be lowercase
+ return u1.getProtocol().equals(u2.getProtocol());
+ }
+
+ private static boolean sameHost(URL u1, URL u2) {
+ String host = u1.getHost();
+ String otherHost = u2.getHost();
+ if (host == null || otherHost == null) {
+ return (host == null && otherHost == null);
+ } else {
+ //avoid slow comparison for strings of different length
+ return ((host.length() == otherHost.length())
+ && host.equalsIgnoreCase(otherHost));
+ }
+ }
+
+ private static boolean samePort(URL u1, URL u2) {
+ return getPort(u1) == getPort(u2);
+ }
+
+ public static int getPort(URL u) {
+ if (u.getPort() != -1) {
+ return u.getPort();
+ } else {
+ return u.getDefaultPort();
+ }
+ }
+
+ public static URL getBase(URL url) {
+ if (url == null) return null;
+ String file = url.getFile();
+ if (file != null) {
+ int idx = file.lastIndexOf('/');
+ if (idx != -1 ) {
+ file = file.substring(0, idx + 1);
+ }
+ try {
+ return new URL(
+ url.getProtocol(),
+ url.getHost(),
+ url.getPort(),
+ file);
+ } catch(MalformedURLException mue) {
+ System.err.println(mue.getMessage());
+ }
+ }
+ // Just return same URL
+ return url;
+ }
+
+ private static String getEmbeddedVersionPath(String path, String version) {
+ int index = path.lastIndexOf("/");
+ String filename = path.substring(index + 1);
+ path = path.substring(0, index + 1);
+
+ String ext = null;
+ index = filename.lastIndexOf(".");
+ if (index != -1) {
+ ext = filename.substring(index + 1);
+ filename = filename.substring(0, index);
+ }
+
+ StringBuilder filenameSB = new StringBuilder(filename);
+ if (version != null) {
+ filenameSB.append("__V");
+ filenameSB.append(version);
+ }
+ if (ext != null) {
+ filenameSB.append(".");
+ filenameSB.append(ext);
+ }
+
+ path += filenameSB.toString();
+ return path;
+ }
+
+ public static URL getEmbeddedVersionURL(URL u, String version) throws Exception {
+ if (u == null) {
+ return null;
+ }
+
+ if (version == null || version.indexOf("*") != -1
+ || version.indexOf("+") != -1) {
+ // Do not support * or + in version string
+ return u;
+ }
+
+ URL versionURL = null;
+
+ String protocol = u.getProtocol();
+ String host = u.getHost();
+ int port = u.getPort();
+ String path = u.getPath();
+
+ path = getEmbeddedVersionPath(path, version);
+
+ versionURL = new URL(protocol, host, port, path);
+
+ return versionURL;
+ }
+}