/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you 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 org.apache.smscserver.util; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.PrintWriter; import java.io.Reader; import java.io.StringWriter; import java.io.Writer; import java.util.Random; /** * <strong>Internal class, do not use directly.</strong> * * IO utility methods. * * <b>Note: Why not use commons-io?</b> While many of these utility methods are also provided by the Apache commons-io * library we prefer to our own implementation to, using a external library might cause additional constraints on users * embedding SmscServer. * * @author hceylan */ public class IoUtils { /** * Random number generator to make unique file name */ private final static Random RANDOM_GEN = new Random(System.currentTimeMillis()); /** * No exception <code>InputStream</code> close method. */ public final static void close(InputStream is) { if (is != null) { try { is.close(); } catch (Exception ex) { } } } /** * No exception <code>OutputStream</code> close method. */ public final static void close(OutputStream os) { if (os != null) { try { os.close(); } catch (Exception ex) { } } } /** * No exception <code>java.io.Reader</code> close method. */ public final static void close(Reader rd) { if (rd != null) { try { rd.close(); } catch (Exception ex) { } } } /** * No exception <code>java.io.Writer</code> close method. */ public final static void close(Writer wr) { if (wr != null) { try { wr.close(); } catch (Exception ex) { } } } /** * Copy chars from a <code>InputStream</code> to a <code>OutputStream</code> . * * @param bufferSize * Size of internal buffer to use. */ public final static void copy(InputStream input, OutputStream output, int bufferSize) throws IOException { byte buffer[] = new byte[bufferSize]; int n = 0; while ((n = input.read(buffer)) != -1) { output.write(buffer, 0, n); } } /** * Copy chars from a <code>Reader</code> to a <code>Writer</code>. * * @param bufferSize * Size of internal buffer to use. */ public final static void copy(Reader input, Writer output, int bufferSize) throws IOException { char buffer[] = new char[bufferSize]; int n = 0; while ((n = input.read(buffer)) != -1) { output.write(buffer, 0, n); } } public final static void delete(File file) throws IOException { if (file.isDirectory()) { IoUtils.deleteDir(file); } else { IoUtils.deleteFile(file); } } private final static void deleteDir(File dir) throws IOException { File[] children = dir.listFiles(); if (children == null) { return; } for (File file : children) { IoUtils.delete(file); } if (!dir.delete()) { throw new IOException("Failed to delete directory: " + dir); } } private final static void deleteFile(File file) throws IOException { if (!file.delete()) { // hack around bug where files will sometimes not be deleted on // Windows if (OS.isFamilyWindows()) { System.gc(); } try { Thread.sleep(10); } catch (InterruptedException e) { } if (!file.delete()) { throw new IOException("Failed to delete file: " + file); } } } /** * Get a <code>BufferedInputStream</code>. */ public final static BufferedInputStream getBufferedInputStream(InputStream in) { BufferedInputStream bin = null; if (in instanceof java.io.BufferedInputStream) { bin = (BufferedInputStream) in; } else { bin = new BufferedInputStream(in); } return bin; } /** * Get a <code>BufferedOutputStream</code>. */ public final static BufferedOutputStream getBufferedOutputStream(OutputStream out) { BufferedOutputStream bout = null; if (out instanceof java.io.BufferedOutputStream) { bout = (BufferedOutputStream) out; } else { bout = new BufferedOutputStream(out); } return bout; } /** * Get <code>BufferedReader</code>. */ public final static BufferedReader getBufferedReader(Reader reader) { BufferedReader buffered = null; if (reader instanceof java.io.BufferedReader) { buffered = (BufferedReader) reader; } else { buffered = new BufferedReader(reader); } return buffered; } /** * Get <code>BufferedWriter</code>. */ public final static BufferedWriter getBufferedWriter(Writer wr) { BufferedWriter bw = null; if (wr instanceof java.io.BufferedWriter) { bw = (BufferedWriter) wr; } else { bw = new BufferedWriter(wr); } return bw; } /** * Get exception stack trace. */ public final static String getStackTrace(Throwable ex) { String result = ""; if (ex != null) { try { StringWriter sw = new StringWriter(); PrintWriter pw = new PrintWriter(sw); ex.printStackTrace(pw); pw.close(); sw.close(); result = sw.toString(); } catch (Exception e) { e.printStackTrace(); } } return result; } /** * Get unique file object. */ public final static File getUniqueFile(File oldFile) { File newFile = oldFile; while (true) { if (!newFile.exists()) { break; } newFile = new File(oldFile.getAbsolutePath() + '.' + Math.abs(IoUtils.RANDOM_GEN.nextLong())); } return newFile; } /** * Read fully from stream */ public final static String readFully(InputStream input) throws IOException { StringWriter writer = new StringWriter(); InputStreamReader reader = new InputStreamReader(input); IoUtils.copy(reader, writer, 1024); return writer.toString(); } /** * Read fully from reader */ public final static String readFully(Reader reader) throws IOException { StringWriter writer = new StringWriter(); IoUtils.copy(reader, writer, 1024); return writer.toString(); } /** * Read fully from string * * @throws IOException * @throws FileNotFoundException */ public final static String readFully(String filename) throws FileNotFoundException, IOException { return IoUtils.readFully(new FileReader(filename)); } }