Java tutorial
/* * Copyright 2006 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ package com.google.gwt.util.tools; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.LineNumberReader; import java.io.OutputStream; import java.io.PrintWriter; import java.io.RandomAccessFile; import java.io.Reader; import java.io.StringReader; import java.io.Writer; import java.net.Socket; import java.net.URI; import java.net.URL; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.util.Iterator; import java.util.Map; import java.util.Set; import java.util.Map.Entry; /** * A smattering of useful functions. */ public final class Utility { /** * Per thread MD5 instance. */ private static final ThreadLocal<MessageDigest> perThreadMd5 = new ThreadLocal<MessageDigest>() { @Override protected MessageDigest initialValue() { try { return MessageDigest.getInstance("MD5"); } catch (NoSuchAlgorithmException e) { return null; } }; }; public static char[] HEX_CHARS = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; private static String sInstallPath = null; /** * Helper that ignores exceptions during close, because what are you going to * do? */ public static void close(InputStream is) { try { if (is != null) { is.close(); } } catch (IOException e) { } } /** * Helper that ignores exceptions during close, because what are you going to * do? */ public static void close(OutputStream os) { try { if (os != null) { os.close(); } } catch (IOException e) { } } /** * Helper that ignores exceptions during close, because what are you going to * do? */ public static void close(RandomAccessFile f) { if (f != null) { try { f.close(); } catch (IOException e) { } } } /** * Helper that ignores exceptions during close, because what are you going to * do? */ public static void close(Reader reader) { try { if (reader != null) { reader.close(); } } catch (IOException e) { } } /** * Helper that ignores exceptions during close, because what are you going to * do? */ public static void close(Socket socket) { try { if (socket != null) { socket.close(); } } catch (IOException e) { } } /** * Helper that ignores exceptions during close, because what are you going to * do? */ public static void close(Writer writer) { try { if (writer != null) { writer.close(); } } catch (IOException e) { } } /** * @param parent Parent directory * @param fileName New file name * @param overwrite Is overwriting an existing file allowed? * @return Handle to the file * @throws IOException If the file cannot be created, or if the file already * existed and overwrite was false. */ public static File createNormalFile(File parent, String fileName, boolean overwrite, boolean ignore) throws IOException { File file = new File(parent, fileName); if (file.createNewFile()) { System.out.println("Created file " + file); return file; } if (!file.exists() || file.isDirectory()) { throw new IOException(file.getPath() + " : could not create normal file."); } if (ignore) { System.out.println(file + " already exists; skipping"); return null; } if (!overwrite) { throw new IOException(file.getPath() + " : already exists; please remove it or use the -overwrite or -ignore option."); } System.out.println("Overwriting existing file " + file); return file; } /** * @param parent Parent directory of the requested directory. * @param dirName Requested name for the directory. * @param create Create the directory if it does not already exist? * @return A {@link File} representing a directory that now exists. * @throws IOException If the directory is not found and/or cannot be created. */ public static File getDirectory(File parent, String dirName, boolean create) throws IOException { File dir = new File(parent, dirName); boolean alreadyExisted = dir.exists(); if (create) { // No need to check mkdirs result because we check for dir.exists() dir.mkdirs(); } if (!dir.exists() || !dir.isDirectory()) { if (create) { throw new IOException(dir.getPath() + " : could not create directory."); } else { throw new IOException(dir.getPath() + " : could not find directory."); } } if (create && !alreadyExisted) { System.out.println("Created directory " + dir); } return dir; } /** * @param dirPath Requested path for the directory. * @param create Create the directory if it does not already exist? * @return A {@link File} representing a directory that now exists. * @throws IOException If the directory is not found and/or cannot be created. */ public static File getDirectory(String dirPath, boolean create) throws IOException { return getDirectory(null, dirPath, create); } /** * Gets the contents of a file from the class path as a String. Note: this * method is only guaranteed to work for resources in the same class loader * that contains this {@link Utility} class. * * @param partialPath the partial path to the resource on the class path * @return the contents of the file * @throws IOException if the file could not be found or an error occurred * while reading it */ public static String getFileFromClassPath(String partialPath) throws IOException { InputStream in = Utility.class.getClassLoader().getResourceAsStream(partialPath); try { if (in == null) { throw new FileNotFoundException(partialPath); } ByteArrayOutputStream os = new ByteArrayOutputStream(); streamOut(in, os, 1024); return new String(os.toByteArray(), "UTF-8"); } finally { close(in); } } public static String getInstallPath() { if (sInstallPath == null) { computeInstallationPath(); } return sInstallPath; } /** * Generate MD5 digest. * * @param input input data to be hashed. * @return MD5 digest. */ public static byte[] getMd5Digest(byte[] input) { MessageDigest md5 = perThreadMd5.get(); md5.reset(); md5.update(input); return md5.digest(); } /** * A 4-digit hex result. */ public static void hex4(char c, StringBuffer sb) { sb.append(HEX_CHARS[(c & 0xF000) >> 12]); sb.append(HEX_CHARS[(c & 0x0F00) >> 8]); sb.append(HEX_CHARS[(c & 0x00F0) >> 4]); sb.append(HEX_CHARS[c & 0x000F]); } /** * Creates a randomly-named temporary directory. * * @param baseDir base directory to contain the new directory. May be * {@code null}, in which case the directory given by the * {@code java.io.tmpdir} system property will be used. * @param prefix the initial characters of the new directory name * @return a newly-created temporary directory; the caller must delete this * directory (either when done or on VM exit) */ public static File makeTemporaryDirectory(File baseDir, String prefix) throws IOException { if (baseDir == null) { baseDir = new File(System.getProperty("java.io.tmpdir")); } // No need to check the result of this mkdirs call because // we will detect the subsequent failure baseDir.mkdirs(); // Try this a few times due to non-atomic delete+mkdir operations. for (int tries = 0; tries < 3; ++tries) { File result = File.createTempFile(prefix, null, baseDir); if (!result.delete()) { throw new IOException("Couldn't delete temporary file " + result.getAbsolutePath() + " to replace with a directory."); } if (result.mkdirs()) { // Success. return result; } } throw new IOException("Couldn't create temporary directory after 3 tries in " + baseDir.getAbsolutePath()); } public static void streamOut(File file, OutputStream out, int bufferSize) throws IOException { FileInputStream fis = null; try { fis = new FileInputStream(file); streamOut(fis, out, bufferSize); } finally { com.google.gwt.util.tools.Utility.close(fis); } } public static void streamOut(InputStream in, OutputStream out, int bufferSize) throws IOException { assert (bufferSize >= 0); byte[] buffer = new byte[bufferSize]; int bytesRead = 0; while (true) { bytesRead = in.read(buffer); if (bytesRead >= 0) { // Copy the bytes out. out.write(buffer, 0, bytesRead); } else { // End of input stream. return; } } } /** * Returns a string representation of the byte array as a series of * hexadecimal characters. * * @param bytes byte array to convert * @return a string representation of the byte array as a series of * hexadecimal characters */ public static String toHexString(byte[] bytes) { char[] hexString = new char[2 * bytes.length]; int j = 0; for (int i = 0; i < bytes.length; i++) { hexString[j++] = HEX_CHARS[(bytes[i] & 0xF0) >> 4]; hexString[j++] = HEX_CHARS[bytes[i] & 0x0F]; } return new String(hexString); } public static void writeTemplateBinaryFile(File file, byte[] contents) throws IOException { FileOutputStream o = new FileOutputStream(file); o.write(contents); close(o); } public static void writeTemplateFile(File file, String contents, Map<String, String> replacements) throws IOException { String replacedContents = contents; Set<Entry<String, String>> entries = replacements.entrySet(); for (Iterator<Entry<String, String>> iter = entries.iterator(); iter.hasNext();) { Entry<String, String> entry = iter.next(); String replaceThis = entry.getKey(); String withThis = entry.getValue(); withThis = withThis.replaceAll("\\\\", "\\\\\\\\"); withThis = withThis.replaceAll("\\$", "\\\\\\$"); replacedContents = replacedContents.replaceAll(replaceThis, withThis); } PrintWriter pw = new PrintWriter(file); LineNumberReader lnr = new LineNumberReader(new StringReader(replacedContents)); for (String line = lnr.readLine(); line != null; line = lnr.readLine()) { pw.println(line); } close(pw); } private static void computeInstallationPath() { try { String override = System.getProperty("gwt.devjar"); if (override == null) { String partialPath = Utility.class.getName().replace('.', '/').concat(".class"); URL url = Utility.class.getClassLoader().getResource(partialPath); if (url != null && "jar".equals(url.getProtocol())) { String path = url.toString(); String jarPath = path.substring(path.indexOf("file:"), path.lastIndexOf('!')); File devJarFile = new File(URI.create(jarPath)); if (!devJarFile.isFile()) { throw new IOException("Could not find jar file; " + devJarFile.getCanonicalPath() + " does not appear to be a valid file"); } String dirPath = jarPath.substring(0, jarPath.lastIndexOf('/') + 1); File installDirFile = new File(URI.create(dirPath)); if (!installDirFile.isDirectory()) { throw new IOException("Could not find installation directory; " + installDirFile.getCanonicalPath() + " does not appear to be a valid directory"); } sInstallPath = installDirFile.getCanonicalPath().replace(File.separatorChar, '/'); } else { throw new IOException( "Cannot determine installation directory; apparently not running from a jar"); } } else { override = override.replace('\\', '/'); int pos = override.lastIndexOf('/'); if (pos < 0) { sInstallPath = ""; } else { sInstallPath = override.substring(0, pos); } } } catch (IOException e) { throw new RuntimeException("Installation problem detected, please reinstall GWT", e); } } }