org.iherus.codegen.utils.IOUtils Maven / Gradle / Ivy
package org.iherus.codegen.utils;
import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.net.HttpURLConnection;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.URLConnection;
import java.nio.channels.Selector;
/**
* IOUtils.
*
* copy from 'org.apache.commons.io.IOUtils'.
*
* @since 1.0.0
*/
public class IOUtils {
private IOUtils() {
super();
}
/**
* Closes a URLConnection.
*
* @param conn the connection to close.
* @since 2.4
*/
public static void close(URLConnection conn) {
if (conn instanceof HttpURLConnection) {
((HttpURLConnection) conn).disconnect();
}
}
/**
* Unconditionally close an Reader.
*
* Equivalent to {@link Reader#close()}, except any exceptions will be ignored.
* This is typically used in finally blocks.
*
* Example code:
*
* char[] data = new char[1024];
* Reader in = null;
* try {
* in = new FileReader("foo.txt");
* in.read(data);
* in.close(); //close errors are handled
* } catch (Exception e) {
* // error handling
* } finally {
* IOUtils.closeQuietly(in);
* }
*
*
* @param input the Reader to close, may be null or already closed
*/
public static void closeQuietly(Reader input) {
closeQuietly((Closeable)input);
}
/**
* Unconditionally close a Writer.
*
* Equivalent to {@link Writer#close()}, except any exceptions will be ignored.
* This is typically used in finally blocks.
*
* Example code:
*
* Writer out = null;
* try {
* out = new StringWriter();
* out.write("Hello World");
* out.close(); //close errors are handled
* } catch (Exception e) {
* // error handling
* } finally {
* IOUtils.closeQuietly(out);
* }
*
*
* @param output the Writer to close, may be null or already closed
*/
public static void closeQuietly(Writer output) {
closeQuietly((Closeable)output);
}
/**
* Unconditionally close an InputStream.
*
* Equivalent to {@link InputStream#close()}, except any exceptions will be ignored.
* This is typically used in finally blocks.
*
* Example code:
*
* byte[] data = new byte[1024];
* InputStream in = null;
* try {
* in = new FileInputStream("foo.txt");
* in.read(data);
* in.close(); //close errors are handled
* } catch (Exception e) {
* // error handling
* } finally {
* IOUtils.closeQuietly(in);
* }
*
*
* @param input the InputStream to close, may be null or already closed
*/
public static void closeQuietly(InputStream input) {
closeQuietly((Closeable)input);
}
/**
* Unconditionally close an OutputStream.
*
* Equivalent to {@link OutputStream#close()}, except any exceptions will be ignored.
* This is typically used in finally blocks.
*
* Example code:
*
* byte[] data = "Hello, World".getBytes();
*
* OutputStream out = null;
* try {
* out = new FileOutputStream("foo.txt");
* out.write(data);
* out.close(); //close errors are handled
* } catch (IOException e) {
* // error handling
* } finally {
* IOUtils.closeQuietly(out);
* }
*
*
* @param output the OutputStream to close, may be null or already closed
*/
public static void closeQuietly(OutputStream output) {
closeQuietly((Closeable)output);
}
/**
* Unconditionally close a Closeable.
*
* Equivalent to {@link Closeable#close()}, except any exceptions will be ignored.
* This is typically used in finally blocks.
*
* Example code:
*
* Closeable closeable = null;
* try {
* closeable = new FileReader("foo.txt");
* // process closeable
* closeable.close();
* } catch (Exception e) {
* // error handling
* } finally {
* IOUtils.closeQuietly(closeable);
* }
*
*
* @param closeable the object to close, may be null or already closed
* @since 2.0
*/
public static void closeQuietly(Closeable closeable) {
try {
if (closeable != null) {
closeable.close();
}
} catch (IOException ioe) {
// ignore
}
}
/**
* Unconditionally close a Socket.
*
* Equivalent to {@link Socket#close()}, except any exceptions will be ignored.
* This is typically used in finally blocks.
*
* Example code:
*
* Socket socket = null;
* try {
* socket = new Socket("http://www.foo.com/", 80);
* // process socket
* socket.close();
* } catch (Exception e) {
* // error handling
* } finally {
* IOUtils.closeQuietly(socket);
* }
*
*
* @param sock the Socket to close, may be null or already closed
* @since 2.0
*/
public static void closeQuietly(Socket sock){
if (sock != null){
try {
sock.close();
} catch (IOException ioe) {
// ignored
}
}
}
/**
* Unconditionally close a Selector.
*
* Equivalent to {@link Selector#close()}, except any exceptions will be ignored.
* This is typically used in finally blocks.
*
* Example code:
*
* Selector selector = null;
* try {
* selector = Selector.open();
* // process socket
*
* } catch (Exception e) {
* // error handling
* } finally {
* IOUtils.closeQuietly(selector);
* }
*
*
* @param selector the Selector to close, may be null or already closed
* @since 2.2
*/
public static void closeQuietly(Selector selector){
if (selector != null){
try {
selector.close();
} catch (IOException ioe) {
// ignored
}
}
}
/**
* Unconditionally close a ServerSocket.
*
* Equivalent to {@link ServerSocket#close()}, except any exceptions will be ignored.
* This is typically used in finally blocks.
*
* Example code:
*
* ServerSocket socket = null;
* try {
* socket = new ServerSocket();
* // process socket
* socket.close();
* } catch (Exception e) {
* // error handling
* } finally {
* IOUtils.closeQuietly(socket);
* }
*
*
* @param sock the ServerSocket to close, may be null or already closed
* @since 2.2
*/
public static void closeQuietly(ServerSocket sock){
if (sock != null){
try {
sock.close();
} catch (IOException ioe) {
// ignored
}
}
}
}