/**
* 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);
}
}
}
