diff options
Diffstat (limited to 'trunk/infrastructure/net.appjet.common/util/BetterFile.java')
| -rw-r--r-- | trunk/infrastructure/net.appjet.common/util/BetterFile.java | 280 |
1 files changed, 280 insertions, 0 deletions
diff --git a/trunk/infrastructure/net.appjet.common/util/BetterFile.java b/trunk/infrastructure/net.appjet.common/util/BetterFile.java new file mode 100644 index 0000000..c674810 --- /dev/null +++ b/trunk/infrastructure/net.appjet.common/util/BetterFile.java @@ -0,0 +1,280 @@ +/** + * Copyright 2009 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 net.appjet.common.util; + +import java.io.BufferedReader; +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.IOException; +import java.io.*; + + +/** + * A bunch of stuff that should've been in the Java Standard Libraries. + */ +public class BetterFile { + public static String getFileContents(File f, boolean t) throws FileNotFoundException { + FileInputStream in; + try { + in = new FileInputStream(f); + } catch (FileNotFoundException e) { + if (t) throw e; + return null; + } + return getStreamContents(in); + } + + public static String getFileContents(File f) { + try { + return getFileContents(f, false); + } catch (FileNotFoundException e) { + // won't ever get here. + } + return null; + } + + public static String getBinaryFileContents(File f) { + FileInputStream in; + try { + in = new FileInputStream(f); + } catch (FileNotFoundException e) { + e.printStackTrace(); + return null; + } + + return getBinaryStreamContents(in); + } + + // Using the non-converting String contructor here. Yum. + @SuppressWarnings({"deprecation"}) + public static String getBinaryStreamContents(InputStream in) { + StringBuilder out = new StringBuilder(); + byte[] b = new byte[4096]; + try { + for (int n; (n = in.read(b)) != -1 ;) { + out.append(new String(b, 0, 0, n)); + } + } catch (IOException e) { + e.printStackTrace(); + return null; + } + return out.toString(); + } + + public static String getStreamContents(InputStream instream) { + InputStreamReader in = new InputStreamReader(instream, java.nio.charset.Charset.forName("UTF-8")); + StringBuilder out = new StringBuilder(); + + char[] b = new char[4096]; + try { + for (int n; (n = in.read(b)) != -1; ){ + out.append(b, 0, n); + } + in.close(); + } catch (IOException e) { + e.printStackTrace(); + return null; + } + return out.toString(); + } + + public static String getBinaryFileContents(String filename) { + return getBinaryFileContents(new File(filename)); + } + + public static String getFileContents(String filename) { + return getFileContents(new File(filename)); + } + + public static String getFileContents(String filename, boolean t) throws FileNotFoundException { + return getFileContents(new File(filename), t); + } + + public static byte[] getStreamBytes(InputStream instream) { + byte[] b = new byte[8192]; + ByteArrayOutputStream baos = new ByteArrayOutputStream(16384); + try { + for (int n; (n = instream.read(b)) != -1;) { + baos.write(b, 0, n); + } + instream.close(); + } catch (IOException e) { + e.printStackTrace(); + return null; + } + return baos.toByteArray(); + } + + public static String getReaderString(BufferedReader reader) { + StringBuffer out = new StringBuffer(); + char[] c = new char[8192]; + try { + for (int n; (n = reader.read(c, 0, c.length)) != -1;) { + out.append(c, 0, n); + } + reader.close(); + } catch (IOException e) { + e.printStackTrace(); + return null; + } + return out.toString(); + } + + public static byte[] getFileBytes(File f) { + try { + return getStreamBytes(new FileInputStream(f)); + } catch (IOException e) { + e.printStackTrace(); + return null; + } + } + + public static byte[] getFileBytes(String filename) { + return getFileBytes(new File(filename)); + } + + public static String getUnicodeFile(File f) throws FileNotFoundException { + return getReaderString(new BufferedReader(new UnicodeReader(new FileInputStream(f), null))); + } + + public static String getUnicodeFile(String filename) throws FileNotFoundException { + return getUnicodeFile(new File(filename)); + } + + public static String stringFromUnicode(byte[] bytes) { + return getReaderString(new BufferedReader(new UnicodeReader(new ByteArrayInputStream(bytes), null))); + } + + // Ripped from: http://koti.mbnet.fi/akini/java/unicodereader/ + /** + version: 1.1 / 2007-01-25 + - changed BOM recognition ordering (longer boms first) + + Original pseudocode : Thomas Weidenfeller + Implementation tweaked: Aki Nieminen + + http://www.unicode.org/unicode/faq/utf_bom.html + BOMs: + 00 00 FE FF = UTF-32, big-endian + FF FE 00 00 = UTF-32, little-endian + EF BB BF = UTF-8, + FE FF = UTF-16, big-endian + FF FE = UTF-16, little-endian + + Win2k Notepad: + Unicode format = UTF-16LE + ***/ + + /** + * Generic unicode textreader, which will use BOM mark + * to identify the encoding to be used. If BOM is not found + * then use a given default or system encoding. + */ + public static class UnicodeReader extends Reader { + PushbackInputStream internalIn; + InputStreamReader internalIn2 = null; + String defaultEnc; + + private static final int BOM_SIZE = 4; + + /** + * + * @param in inputstream to be read + * @param defaultEnc default encoding if stream does not have + * BOM marker. Give NULL to use system-level default. + */ + UnicodeReader(InputStream in, String defaultEnc) { + internalIn = new PushbackInputStream(in, BOM_SIZE); + this.defaultEnc = defaultEnc; + } + + public String getDefaultEncoding() { + return defaultEnc; + } + + /** + * Get stream encoding or NULL if stream is uninitialized. + * Call init() or read() method to initialize it. + */ + public String getEncoding() { + if (internalIn2 == null) return null; + return internalIn2.getEncoding(); + } + + /** + * Read-ahead four bytes and check for BOM marks. Extra bytes are + * unread back to the stream, only BOM bytes are skipped. + */ + protected void init() throws IOException { + if (internalIn2 != null) return; + + String encoding; + byte bom[] = new byte[BOM_SIZE]; + int n, unread; + n = internalIn.read(bom, 0, bom.length); + + if ( (bom[0] == (byte)0x00) && (bom[1] == (byte)0x00) && + (bom[2] == (byte)0xFE) && (bom[3] == (byte)0xFF) ) { + encoding = "UTF-32BE"; + unread = n - 4; + } else if ( (bom[0] == (byte)0xFF) && (bom[1] == (byte)0xFE) && + (bom[2] == (byte)0x00) && (bom[3] == (byte)0x00) ) { + encoding = "UTF-32LE"; + unread = n - 4; + } else if ( (bom[0] == (byte)0xEF) && (bom[1] == (byte)0xBB) && + (bom[2] == (byte)0xBF) ) { + encoding = "UTF-8"; + unread = n - 3; + } else if ( (bom[0] == (byte)0xFE) && (bom[1] == (byte)0xFF) ) { + encoding = "UTF-16BE"; + unread = n - 2; + } else if ( (bom[0] == (byte)0xFF) && (bom[1] == (byte)0xFE) ) { + encoding = "UTF-16LE"; + unread = n - 2; + } else { + // Unicode BOM mark not found, unread all bytes + encoding = defaultEnc; + unread = n; + } + //System.out.println("read=" + n + ", unread=" + unread); + + if (unread > 0) internalIn.unread(bom, (n - unread), unread); + + // Use given encoding + if (encoding == null) { + internalIn2 = new InputStreamReader(internalIn); + } else { + internalIn2 = new InputStreamReader(internalIn, encoding); + } + } + + public void close() throws IOException { + init(); + internalIn2.close(); + } + + public int read(char[] cbuf, int off, int len) throws IOException { + init(); + return internalIn2.read(cbuf, off, len); + } + + } +} |