All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.fireflysource.common.io.IO Maven / Gradle / Ivy

There is a newer version: 5.0.2
Show newest version
package com.fireflysource.common.io;

import java.io.*;
import java.nio.ByteBuffer;
import java.nio.channels.GatheringByteChannel;
import java.nio.charset.Charset;

public class IO {

    public final static String CRLF = "\015\012";

    public final static byte[] CRLF_BYTES = {(byte) '\015', (byte) '\012'};

    public static final int bufferSize = 64 * 1024;
    private static NullOS NULL_STREAM = new NullOS();
    private static ClosedIS CLOSED_STREAM = new ClosedIS();
    private static NullWrite NULL_WRITER = new NullWrite();
    private static PrintWriter NULL_PRINT_WRITER = new PrintWriter(NULL_WRITER);

    /**
     * Copy Stream in to Stream out until EOF or exception.
     *
     * @param in  the input stream to read from (until EOF)
     * @param out the output stream to write to
     * @throws IOException if unable to copy streams
     */
    public static void copy(InputStream in, OutputStream out) throws IOException {
        copy(in, out, -1);
    }

    /**
     * Copy Reader to Writer out until EOF or exception.
     *
     * @param in  the read to read from (until EOF)
     * @param out the writer to write to
     * @throws IOException if unable to copy the streams
     */
    public static void copy(Reader in, Writer out) throws IOException {
        copy(in, out, -1);
    }

    /**
     * Copy Stream in to Stream for byteCount bytes or until EOF or exception.
     *
     * @param in        the stream to read from
     * @param out       the stream to write to
     * @param byteCount the number of bytes to copy
     * @throws IOException if unable to copy the streams
     */
    public static void copy(InputStream in, OutputStream out, long byteCount) throws IOException {
        byte[] buffer = new byte[bufferSize];
        int len;

        if (byteCount >= 0) {
            while (byteCount > 0) {
                int max = byteCount < bufferSize ? (int) byteCount : bufferSize;
                len = in.read(buffer, 0, max);

                if (len == -1)
                    break;

                byteCount -= len;
                out.write(buffer, 0, len);
            }
        } else {
            while (true) {
                len = in.read(buffer, 0, bufferSize);
                if (len < 0)
                    break;
                out.write(buffer, 0, len);
            }
        }
    }

    /**
     * Copy Reader to Writer for byteCount bytes or until EOF or exception.
     *
     * @param in        the Reader to read from
     * @param out       the Writer to write to
     * @param byteCount the number of bytes to copy
     * @throws IOException if unable to copy streams
     */
    public static void copy(Reader in, Writer out, long byteCount) throws IOException {
        char[] buffer = new char[bufferSize];
        int len;

        if (byteCount >= 0) {
            while (byteCount > 0) {
                if (byteCount < bufferSize)
                    len = in.read(buffer, 0, (int) byteCount);
                else
                    len = in.read(buffer, 0, bufferSize);

                if (len == -1)
                    break;

                byteCount -= len;
                out.write(buffer, 0, len);
            }
        } else if (out instanceof PrintWriter) {
            PrintWriter pout = (PrintWriter) out;
            while (!pout.checkError()) {
                len = in.read(buffer, 0, bufferSize);
                if (len == -1)
                    break;
                out.write(buffer, 0, len);
            }
        } else {
            while (true) {
                len = in.read(buffer, 0, bufferSize);
                if (len == -1)
                    break;
                out.write(buffer, 0, len);
            }
        }
    }

    /**
     * Copy files or directories
     *
     * @param from the file to copy
     * @param to   the destination to copy to
     * @throws IOException if unable to copy
     */
    public static void copy(File from, File to) throws IOException {
        if (from.isDirectory())
            copyDir(from, to);
        else
            copyFile(from, to);
    }

    public static void copyDir(File from, File to) throws IOException {
        if (to.exists()) {
            if (!to.isDirectory())
                throw new IllegalArgumentException(to.toString());
        } else
            to.mkdirs();

        File[] files = from.listFiles();
        if (files != null) {
            for (File file : files) {
                String name = file.getName();
                if (".".equals(name) || "..".equals(name))
                    continue;
                copy(file, new File(to, name));
            }
        }
    }

    public static void copyFile(File from, File to) throws IOException {
        try (InputStream in = new FileInputStream(from); OutputStream out = new FileOutputStream(to)) {
            copy(in, out);
        }
    }

    /**
     * Read input stream to string.
     *
     * @param in the stream to read from (until EOF)
     * @return the String parsed from stream (default Charset)
     * @throws IOException if unable to read the stream (or handle the charset)
     */
    public static String toString(InputStream in) throws IOException {
        return toString(in, (Charset) null);
    }

    /**
     * Read input stream to string.
     *
     * @param in       the stream to read from (until EOF)
     * @param encoding the encoding to use (can be null to use default Charset)
     * @return the String parsed from the stream
     * @throws IOException if unable to read the stream (or handle the charset)
     */
    public static String toString(InputStream in, String encoding) throws IOException {
        return toString(in, encoding == null ? null : Charset.forName(encoding));
    }

    /**
     * Read input stream to string.
     *
     * @param in       the stream to read from (until EOF)
     * @param encoding the Charset to use (can be null to use default Charset)
     * @return the String parsed from the stream
     * @throws IOException if unable to read the stream (or handle the charset)
     */
    public static String toString(InputStream in, Charset encoding) throws IOException {
        StringWriter writer = new StringWriter();
        InputStreamReader reader = encoding == null ? new InputStreamReader(in) : new InputStreamReader(in, encoding);

        copy(reader, writer);
        return writer.toString();
    }

    /**
     * Read input stream to string.
     *
     * @param in the reader to read from (until EOF)
     * @return the String parsed from the reader
     * @throws IOException if unable to read the stream (or handle the charset)
     */
    public static String toString(Reader in) throws IOException {
        StringWriter writer = new StringWriter();
        copy(in, writer);
        return writer.toString();
    }

    /**
     * Delete File. This delete will recursively delete directories - BE
     * CAREFULL
     *
     * @param file The file (or directory) to be deleted.
     * @return true if anything was deleted. (note: this does not mean that all
     * content in a directory was deleted)
     */
    public static boolean delete(File file) {
        if (!file.exists())
            return false;
        if (file.isDirectory()) {
            File[] files = file.listFiles();
            for (int i = 0; files != null && i < files.length; i++)
                delete(files[i]);
        }
        return file.delete();
    }

    /**
     * Closes an arbitrary closable, and logs exceptions at ignore level
     *
     * @param closeable the closeable to close
     */
    public static void close(Closeable closeable) {
        try {
            if (closeable != null)
                closeable.close();
        } catch (IOException ignore) {
        }
    }

    /**
     * closes an input stream, and logs exceptions
     *
     * @param is the input stream to close
     */
    public static void close(InputStream is) {
        close((Closeable) is);
    }

    /**
     * closes an output stream, and logs exceptions
     *
     * @param os the output stream to close
     */
    public static void close(OutputStream os) {
        close((Closeable) os);
    }

    /**
     * closes a reader, and logs exceptions
     *
     * @param reader the reader to close
     */
    public static void close(Reader reader) {
        close((Closeable) reader);
    }

    /**
     * closes a writer, and logs exceptions
     *
     * @param writer the writer to close
     */
    public static void close(Writer writer) {
        close((Closeable) writer);
    }

    public static byte[] readBytes(InputStream in) throws IOException {
        ByteArrayOutputStream bout = new ByteArrayOutputStream();
        copy(in, bout);
        return bout.toByteArray();
    }

    /**
     * A gathering write utility wrapper.
     * 

* This method wraps a gather write with a loop that handles the limitations * of some operating systems that have a limit on the number of buffers * written. The method loops on the write until either all the content is * written or no progress is made. * * @param out The GatheringByteChannel to write to * @param buffers The buffers to write * @param offset The offset into the buffers array * @param length The length in buffers to write * @return The total bytes written * @throws IOException if unable write to the GatheringByteChannel */ public static long write(GatheringByteChannel out, ByteBuffer[] buffers, int offset, int length) throws IOException { long total = 0; write: while (length > 0) { // Write as much as we can long wrote = out.write(buffers, offset, length); // If we can't write any more, give up if (wrote == 0) break; // count the total total += wrote; // Look for unwritten content for (int i = offset; i < buffers.length; i++) { if (buffers[i].hasRemaining()) { // loop with new offset and length; length = length - (i - offset); offset = i; continue write; } } length = 0; } return total; } /** * @return An outputstream to nowhere */ public static OutputStream getNullStream() { return NULL_STREAM; } /** * @return An outputstream to nowhere */ public static InputStream getClosedStream() { return CLOSED_STREAM; } /** * @return An writer to nowhere */ public static Writer getNullWriter() { return NULL_WRITER; } /** * @return An writer to nowhere */ public static PrintWriter getNullPrintWriter() { return NULL_PRINT_WRITER; } private static class NullOS extends OutputStream { @Override public void close() { } @Override public void flush() { } @Override public void write(byte[] b) { } @Override public void write(byte[] b, int i, int l) { } @Override public void write(int b) { } } private static class ClosedIS extends InputStream { @Override public int read() throws IOException { return -1; } } private static class NullWrite extends Writer { @Override public void close() { } @Override public void flush() { } @Override public void write(char[] b) { } @Override public void write(char[] b, int o, int l) { } @Override public void write(int b) { } @Override public void write(String s) { } @Override public void write(String s, int o, int l) { } } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy