+ * This class provides static utility methods for input/output operations. + *
+ * The byte-to-char methods and char-to-byte methods involve a conversion step. + * Two methods are provided in each case, one that uses the platform default + * encoding and the other which allows you to specify an encoding. You are + * encouraged to always specify an encoding because relying on the platform + * default can lead to unexpected results, for example when moving from + * development to production. + *
+ * All the methods in this class that read a stream are buffered internally.
+ * This means that there is no cause to use a BufferedInputStream
+ * or BufferedReader. The default buffer size of 4K has been shown
+ * to be efficient in tests.
+ *
+ * Wherever possible, the methods in this class do not flush or close + * the stream. This is to avoid making non-portable assumptions about the + * streams' origin and further use. Thus the caller is still responsible for + * closing streams after use. + *
+ * Origin of code: Excalibur.
+ *
+ * @version $Id: IOUtils.java 1326636 2012-04-16 14:54:53Z ggregory $
+ */
+public class UncheckedIOUtils {
+
+ // NOTE: This class is focussed on InputStream, OutputStream, Reader and
+ // Writer. Each method should take at least one of these as a parameter,
+ // or return one of them.
+ private static final int EOF = -1;
+
+ /**
+ * The Unix directory separator character.
+ */
+ public static final char DIR_SEPARATOR_UNIX = '/';
+
+ /**
+ * The Windows directory separator character.
+ */
+ public static final char DIR_SEPARATOR_WINDOWS = '\\';
+
+ /**
+ * The system directory separator character.
+ */
+ public static final char DIR_SEPARATOR = File.separatorChar;
+
+ /**
+ * The Unix line separator string.
+ */
+ public static final String LINE_SEPARATOR_UNIX = "\n";
+
+ /**
+ * The Windows line separator string.
+ */
+ public static final String LINE_SEPARATOR_WINDOWS = "\r\n";
+
+ /**
+ * The system line separator string.
+ */
+ public static final String LINE_SEPARATOR;
+
+ static {
+ // avoid security issues
+ StringBuilderWriter buf = new StringBuilderWriter(4);
+ PrintWriter out = new PrintWriter(buf);
+ out.println();
+ LINE_SEPARATOR = buf.toString();
+ out.close();
+ }
+
+ /**
+ * The default buffer size ({@value}) to use for
+ * {@link #copyLarge(InputStream, OutputStream)}
+ * and
+ * {@link #copyLarge(Reader, Writer)}
+ */
+ private static final int DEFAULT_BUFFER_SIZE = 1024 * 4;
+
+ /**
+ * The default buffer size to use for the skip() methods.
+ */
+ private static final int SKIP_BUFFER_SIZE = 2048;
+
+ // Allocated in the relevant skip method if necessary.
+ /*
+ * N.B. no need to synchronize these because:
+ * - we don't care if the buffer is created multiple times (the data is ignored)
+ * - we always use the same size buffer, so if it it is recreated it will still be OK
+ * (if the buffer size were variable, we would need to synch. to ensure some other thread
+ * did not create a smaller one)
+ */
+ private static char[] SKIP_CHAR_BUFFER;
+
+ private static byte[] SKIP_BYTE_BUFFER;
+
+ /**
+ * Instances should NOT be constructed in standard programming.
+ */
+ public UncheckedIOUtils() {
+ 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) {
+ }
+ }
+
+ /**
+ * 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) {
+ }
+ }
+ }
+
+ /**
+ * 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) {
+ }
+ }
+ }
+
+ /**
+ * 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) {
+ }
+ }
+ }
+
+ /**
+ * Fetches entire contents of an InputStream and represent
+ * same data as result InputStream.
+ * + * This method is useful where, + *
BufferedInputStream.
+ *
+ * @param input Stream to be fully buffered.
+ * @return A fully buffered stream.
+ * no longer throws IOException if an I/O error occurs
+ * @since 2.0
+ */
+ public static InputStream toBufferedInputStream(InputStream input) {
+ try {
+ return ByteArrayOutputStream.toBufferedInputStream(input);
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Returns the given reader if it is a {@link BufferedReader}, otherwise creates a toBufferedReader for the given
+ * reader.
+ *
+ * @param reader
+ * the reader to wrap or return
+ * @return the given reader or a new {@link BufferedReader} for the given reader
+ * @since 2.2
+ */
+ public static BufferedReader toBufferedReader(Reader reader) {
+ return reader instanceof BufferedReader ? (BufferedReader) reader : new BufferedReader(reader);
+ }
+
+ // read toByteArray
+ //-----------------------------------------------------------------------
+ /**
+ * Get the contents of an InputStream as a byte[].
+ *
+ * This method buffers the input internally, so there is no need to use a
+ * BufferedInputStream.
+ *
+ * @param input the InputStream to read from
+ * @return the requested byte array
+ * no longer throws NullPointerException if the input is null
+ * no longer throws IOException if an I/O error occurs
+ */
+ public static byte[] toByteArray(InputStream input) {
+ try {
+ ByteArrayOutputStream output = new ByteArrayOutputStream();
+ copy(input, output);
+ return output.toByteArray();
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Get contents of an InputStream as a byte[].
+ * Use this method instead of toByteArray(InputStream)
+ * when InputStream size is known.
+ * NOTE: the method checks that the length can safely be cast to an int without truncation
+ * before using {@link IOUtils#toByteArray(java.io.InputStream, int)} to read into the byte array.
+ * (Arrays can have no more than Integer.MAX_VALUE entries anyway)
+ *
+ * @param input the InputStream to read from
+ * @param size the size of InputStream
+ * @return the requested byte array
+ * no longer throws IOException if an I/O error occurs or InputStream size differ from parameter size
+ * no longer throws IllegalArgumentException if size is less than zero or size is greater than Integer.MAX_VALUE
+ * @see IOUtils#toByteArray(java.io.InputStream, int)
+ * @since 2.1
+ */
+ public static byte[] toByteArray(InputStream input, long size) {
+ try {
+ if (size > Integer.MAX_VALUE) {
+ throw new IllegalArgumentException("Size cannot be greater than Integer max value: " + size);
+ }
+ return toByteArray(input, (int) size);
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Get the contents of an InputStream as a byte[].
+ * Use this method instead of toByteArray(InputStream)
+ * when InputStream size is known
+ * @param input the InputStream to read from
+ * @param size the size of InputStream
+ * @return the requested byte array
+ * no longer throws IOException if an I/O error occurs or InputStream size differ from parameter size
+ * no longer throws IllegalArgumentException if size is less than zero
+ * @since 2.1
+ */
+ public static byte[] toByteArray(InputStream input, int size) {
+ try {
+ if (size < 0) {
+ throw new IllegalArgumentException("Size must be equal or greater than zero: " + size);
+ }
+ if (size == 0) {
+ return new byte[0];
+ }
+ byte[] data = new byte[size];
+ int offset = 0;
+ int readed;
+ while (offset < size && (readed = input.read(data, offset, size - offset)) != EOF) {
+ offset += readed;
+ }
+ if (offset != size) {
+ throw new IOException("Unexpected readed size. current: " + offset + ", excepted: " + size);
+ }
+ return data;
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Get the contents of a Reader as a byte[]
+ * using the default character encoding of the platform.
+ *
+ * This method buffers the input internally, so there is no need to use a
+ * BufferedReader.
+ *
+ * @param input the Reader to read from
+ * @return the requested byte array
+ * no longer throws NullPointerException if the input is null
+ * no longer throws IOException if an I/O error occurs
+ */
+ public static byte[] toByteArray(Reader input) {
+ try {
+ return toByteArray(input, Charset.defaultCharset());
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Get the contents of a Reader as a byte[]
+ * using the specified character encoding.
+ *
+ * This method buffers the input internally, so there is no need to use a
+ * BufferedReader.
+ *
+ * @param input the Reader to read from
+ * @param encoding the encoding to use, null means platform default
+ * @return the requested byte array
+ * no longer throws NullPointerException if the input is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 2.3
+ */
+ public static byte[] toByteArray(Reader input, Charset encoding) {
+ try {
+ ByteArrayOutputStream output = new ByteArrayOutputStream();
+ copy(input, output, encoding);
+ return output.toByteArray();
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Get the contents of a Reader as a byte[]
+ * using the specified character encoding.
+ *
+ * Character encoding names can be found at + * IANA. + *
+ * This method buffers the input internally, so there is no need to use a
+ * BufferedReader.
+ *
+ * @param input the Reader to read from
+ * @param encoding the encoding to use, null means platform default
+ * @return the requested byte array
+ * no longer throws NullPointerException if the input is null
+ * no longer throws IOException if an I/O error occurs
+ * no longer throws UnsupportedCharsetException
+ * thrown instead of {@link UnsupportedEncodingException} in version 2.2 if the encoding is not
+ * supported.
+ * @since 1.1
+ */
+ public static byte[] toByteArray(Reader input, String encoding) {
+ try {
+ return toByteArray(input, Charsets.toCharset(encoding));
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Get the contents of a String as a byte[]
+ * using the default character encoding of the platform.
+ *
+ * This is the same as {@link String#getBytes()}.
+ *
+ * @param input the String to convert
+ * @return the requested byte array
+ * no longer throws NullPointerException if the input is null
+ * no longer throws IOException if an I/O error occurs (never occurs)
+ * @deprecated Use {@link String#getBytes()}
+ */
+ @Deprecated
+ public static byte[] toByteArray(String input) {
+ try {
+ return input.getBytes();
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Get the contents of a URI as a byte[].
+ *
+ * @param uri
+ * the URI to read
+ * @return the requested byte array
+ * no longer throws NullPointerException
+ * if the uri is null
+ * no longer throws IOException
+ * if an I/O exception occurs
+ * @since 2.4
+ */
+ public static byte[] toByteArray(URI uri) {
+ try {
+ return IOUtils.toByteArray(uri.toURL());
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Get the contents of a URL as a byte[].
+ *
+ * @param url
+ * the URL to read
+ * @return the requested byte array
+ * no longer throws NullPointerException
+ * if the input is null
+ * no longer throws IOException
+ * if an I/O exception occurs
+ * @since 2.4
+ */
+ public static byte[] toByteArray(URL url) {
+ try {
+ URLConnection conn = url.openConnection();
+ try {
+ return IOUtils.toByteArray(conn);
+ } finally {
+ close(conn);
+ }
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Get the contents of a URLConnection as a byte[].
+ *
+ * @param urlConn
+ * the URLConnection to read
+ * @return the requested byte array
+ * no longer throws NullPointerException
+ * if the urlConn is null
+ * no longer throws IOException
+ * if an I/O exception occurs
+ * @since 2.4
+ */
+ public static byte[] toByteArray(URLConnection urlConn) {
+ try {
+ InputStream inputStream = urlConn.getInputStream();
+ try {
+ return IOUtils.toByteArray(inputStream);
+ } finally {
+ inputStream.close();
+ }
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ // read char[]
+ //-----------------------------------------------------------------------
+ /**
+ * Get the contents of an InputStream as a character array
+ * using the default character encoding of the platform.
+ *
+ * This method buffers the input internally, so there is no need to use a
+ * BufferedInputStream.
+ *
+ * @param is the InputStream to read from
+ * @return the requested character array
+ * no longer throws NullPointerException if the input is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 1.1
+ */
+ public static char[] toCharArray(InputStream is) {
+ try {
+ return toCharArray(is, Charset.defaultCharset());
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Get the contents of an InputStream as a character array
+ * using the specified character encoding.
+ *
+ * This method buffers the input internally, so there is no need to use a
+ * BufferedInputStream.
+ *
+ * @param is the InputStream to read from
+ * @param encoding the encoding to use, null means platform default
+ * @return the requested character array
+ * no longer throws NullPointerException if the input is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 2.3
+ */
+ public static char[] toCharArray(InputStream is, Charset encoding) {
+ try {
+ CharArrayWriter output = new CharArrayWriter();
+ copy(is, output, encoding);
+ return output.toCharArray();
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Get the contents of an InputStream as a character array
+ * using the specified character encoding.
+ *
+ * Character encoding names can be found at + * IANA. + *
+ * This method buffers the input internally, so there is no need to use a
+ * BufferedInputStream.
+ *
+ * @param is the InputStream to read from
+ * @param encoding the encoding to use, null means platform default
+ * @return the requested character array
+ * no longer throws NullPointerException if the input is null
+ * no longer throws IOException if an I/O error occurs
+ * no longer throws UnsupportedCharsetException
+ * thrown instead of {@link UnsupportedEncodingException} in version 2.2 if the encoding is not
+ * supported.
+ * @since 1.1
+ */
+ public static char[] toCharArray(InputStream is, String encoding) {
+ try {
+ return toCharArray(is, Charsets.toCharset(encoding));
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Get the contents of a Reader as a character array.
+ *
+ * This method buffers the input internally, so there is no need to use a
+ * BufferedReader.
+ *
+ * @param input the Reader to read from
+ * @return the requested character array
+ * no longer throws NullPointerException if the input is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 1.1
+ */
+ public static char[] toCharArray(Reader input) {
+ try {
+ CharArrayWriter sw = new CharArrayWriter();
+ copy(input, sw);
+ return sw.toCharArray();
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ // read toString
+ //-----------------------------------------------------------------------
+ /**
+ * Get the contents of an InputStream as a String
+ * using the default character encoding of the platform.
+ *
+ * This method buffers the input internally, so there is no need to use a
+ * BufferedInputStream.
+ *
+ * @param input the InputStream to read from
+ * @return the requested String
+ * no longer throws NullPointerException if the input is null
+ * no longer throws IOException if an I/O error occurs
+ */
+ public static String toString(InputStream input) {
+ try {
+ return toString(input, Charset.defaultCharset());
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Get the contents of an InputStream as a String
+ * using the specified character encoding.
+ *
+ * This method buffers the input internally, so there is no need to use a
+ * BufferedInputStream.
+ *
InputStream to read from
+ * @param encoding the encoding to use, null means platform default
+ * @return the requested String
+ * no longer throws NullPointerException if the input is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 2.3
+ */
+ public static String toString(InputStream input, Charset encoding) {
+ try {
+ StringBuilderWriter sw = new StringBuilderWriter();
+ copy(input, sw, encoding);
+ return sw.toString();
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Get the contents of an InputStream as a String
+ * using the specified character encoding.
+ * + * Character encoding names can be found at + * IANA. + *
+ * This method buffers the input internally, so there is no need to use a
+ * BufferedInputStream.
+ *
+ * @param input the InputStream to read from
+ * @param encoding the encoding to use, null means platform default
+ * @return the requested String
+ * no longer throws NullPointerException if the input is null
+ * no longer throws IOException if an I/O error occurs
+ * no longer throws UnsupportedCharsetException
+ * thrown instead of {@link UnsupportedEncodingException} in version 2.2 if the encoding is not
+ * supported.
+ */
+ public static String toString(InputStream input, String encoding) {
+ try {
+ return toString(input, Charsets.toCharset(encoding));
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Get the contents of a Reader as a String.
+ *
+ * This method buffers the input internally, so there is no need to use a
+ * BufferedReader.
+ *
+ * @param input the Reader to read from
+ * @return the requested String
+ * no longer throws NullPointerException if the input is null
+ * no longer throws IOException if an I/O error occurs
+ */
+ public static String toString(Reader input) {
+ try {
+ StringBuilderWriter sw = new StringBuilderWriter();
+ copy(input, sw);
+ return sw.toString();
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Gets the contents at the given URI.
+ *
+ * @param uri
+ * The URI source.
+ * @return The contents of the URL as a String.
+ * no longer throws IOException if an I/O exception occurs.
+ * @since 2.1
+ */
+ public static String toString(URI uri) {
+ try {
+ return toString(uri, Charset.defaultCharset());
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Gets the contents at the given URI.
+ *
+ * @param uri
+ * The URI source.
+ * @param encoding
+ * The encoding name for the URL contents.
+ * @return The contents of the URL as a String.
+ * no longer throws IOException if an I/O exception occurs.
+ * @since 2.3.
+ */
+ public static String toString(URI uri, Charset encoding) {
+ try {
+ return toString(uri.toURL(), Charsets.toCharset(encoding));
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Gets the contents at the given URI.
+ *
+ * @param uri
+ * The URI source.
+ * @param encoding
+ * The encoding name for the URL contents.
+ * @return The contents of the URL as a String.
+ * no longer throws IOException if an I/O exception occurs.
+ * no longer throws UnsupportedCharsetException
+ * thrown instead of {@link UnsupportedEncodingException} in version 2.2 if the encoding is not
+ * supported.
+ * @since 2.1
+ */
+ public static String toString(URI uri, String encoding) {
+ try {
+ return toString(uri, Charsets.toCharset(encoding));
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Gets the contents at the given URL.
+ *
+ * @param url
+ * The URL source.
+ * @return The contents of the URL as a String.
+ * no longer throws IOException if an I/O exception occurs.
+ * @since 2.1
+ */
+ public static String toString(URL url) {
+ try {
+ return toString(url, Charset.defaultCharset());
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Gets the contents at the given URL.
+ *
+ * @param url
+ * The URL source.
+ * @param encoding
+ * The encoding name for the URL contents.
+ * @return The contents of the URL as a String.
+ * no longer throws IOException if an I/O exception occurs.
+ * @since 2.3
+ */
+ public static String toString(URL url, Charset encoding) {
+ try {
+ InputStream inputStream = url.openStream();
+ try {
+ return toString(inputStream, encoding);
+ } finally {
+ inputStream.close();
+ }
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Gets the contents at the given URL.
+ *
+ * @param url
+ * The URL source.
+ * @param encoding
+ * The encoding name for the URL contents.
+ * @return The contents of the URL as a String.
+ * no longer throws IOException if an I/O exception occurs.
+ * no longer throws UnsupportedCharsetException
+ * thrown instead of {@link UnsupportedEncodingException} in version 2.2 if the encoding is not
+ * supported.
+ * @since 2.1
+ */
+ public static String toString(URL url, String encoding) {
+ try {
+ return toString(url, Charsets.toCharset(encoding));
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Get the contents of a byte[] as a String
+ * using the default character encoding of the platform.
+ *
+ * @param input the byte array to read from
+ * @return the requested String
+ * no longer throws NullPointerException if the input is null
+ * no longer throws IOException if an I/O error occurs (never occurs)
+ * @deprecated Use {@link String#String(byte[])}
+ */
+ @Deprecated
+ public static String toString(byte[] input) {
+ try {
+ return new String(input);
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Get the contents of a byte[] as a String
+ * using the specified character encoding.
+ *
+ * Character encoding names can be found at
+ * IANA.
+ *
+ * @param input the byte array to read from
+ * @param encoding the encoding to use, null means platform default
+ * @return the requested String
+ * no longer throws NullPointerException if the input is null
+ * no longer throws IOException if an I/O error occurs (never occurs)
+ */
+ public static String toString(byte[] input, String encoding) {
+ try {
+ return new String(input, Charsets.toCharset(encoding));
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ // readLines
+ //-----------------------------------------------------------------------
+ /**
+ * Get the contents of an InputStream as a list of Strings,
+ * one entry per line, using the default character encoding of the platform.
+ *
+ * This method buffers the input internally, so there is no need to use a
+ *
+ * This method buffers the input internally, so there is no need to use a
+ *
+ * Character encoding names can be found at
+ * IANA.
+ *
+ * This method buffers the input internally, so there is no need to use a
+ *
+ * This method buffers the input internally, so there is no need to use a
+ *
+ *
+ * The recommended usage pattern is:
+ *
+ *
+ * The recommended usage pattern is:
+ *
+ *
+ * The recommended usage pattern is:
+ *
+ * Character encoding names can be found at
+ * IANA.
+ *
+ * @param input the CharSequence to convert
+ * @param encoding the encoding to use, null means platform default
+ * @return an input stream
+ * no longer throws IOException if the encoding is invalid
+ * no longer throws UnsupportedCharsetException
+ * thrown instead of {@link UnsupportedEncodingException} in version 2.2 if the encoding is not
+ * supported.
+ * @since 2.0
+ */
+ public static InputStream toInputStream(CharSequence input, String encoding) {
+ try {
+ return toInputStream(input, Charsets.toCharset(encoding));
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Convert the specified string to an input stream, encoded as bytes
+ * using the default character encoding of the platform.
+ *
+ * @param input the string to convert
+ * @return an input stream
+ * @since 1.1
+ */
+ public static InputStream toInputStream(String input) {
+ return toInputStream(input, Charset.defaultCharset());
+ }
+
+ /**
+ * Convert the specified string to an input stream, encoded as bytes
+ * using the specified character encoding.
+ *
+ * @param input the string to convert
+ * @param encoding the encoding to use, null means platform default
+ * @return an input stream
+ * @since 2.3
+ */
+ public static InputStream toInputStream(String input, Charset encoding) {
+ return new ByteArrayInputStream(input.getBytes(Charsets.toCharset(encoding)));
+ }
+
+ /**
+ * Convert the specified string to an input stream, encoded as bytes
+ * using the specified character encoding.
+ *
+ * Character encoding names can be found at
+ * IANA.
+ *
+ * @param input the string to convert
+ * @param encoding the encoding to use, null means platform default
+ * @return an input stream
+ * no longer throws IOException if the encoding is invalid
+ * no longer throws UnsupportedCharsetException
+ * thrown instead of {@link UnsupportedEncodingException} in version 2.2 if the encoding is not
+ * supported.
+ * @since 1.1
+ */
+ public static InputStream toInputStream(String input, String encoding) {
+ try {
+ byte[] bytes = input.getBytes(Charsets.toCharset(encoding));
+ return new ByteArrayInputStream(bytes);
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ // write byte[]
+ //-----------------------------------------------------------------------
+ /**
+ * Writes bytes from a
+ * This method uses {@link String#String(byte[])}.
+ *
+ * @param data the byte array to write, do not modify during output,
+ * null ignored
+ * @param output the
+ * This method uses {@link String#String(byte[], String)}.
+ *
+ * @param data the byte array to write, do not modify during output,
+ * null ignored
+ * @param output the
+ * Character encoding names can be found at
+ * IANA.
+ *
+ * This method uses {@link String#String(byte[], String)}.
+ *
+ * @param data the byte array to write, do not modify during output,
+ * null ignored
+ * @param output the
+ * This method uses {@link String#String(char[])} and
+ * {@link String#getBytes()}.
+ *
+ * @param data the char array to write, do not modify during output,
+ * null ignored
+ * @param output the
+ * This method uses {@link String#String(char[])} and
+ * {@link String#getBytes(String)}.
+ *
+ * @param data the char array to write, do not modify during output,
+ * null ignored
+ * @param output the
+ * Character encoding names can be found at
+ * IANA.
+ *
+ * This method uses {@link String#String(char[])} and
+ * {@link String#getBytes(String)}.
+ *
+ * @param data the char array to write, do not modify during output,
+ * null ignored
+ * @param output the
+ * This method uses {@link String#getBytes()}.
+ *
+ * @param data the
+ * This method uses {@link String#getBytes(String)}.
+ *
+ * @param data the
+ * Character encoding names can be found at
+ * IANA.
+ *
+ * This method uses {@link String#getBytes(String)}.
+ *
+ * @param data the
+ * This method uses {@link String#getBytes()}.
+ *
+ * @param data the
+ * This method uses {@link String#getBytes(String)}.
+ *
+ * @param data the
+ * Character encoding names can be found at
+ * IANA.
+ *
+ * This method uses {@link String#getBytes(String)}.
+ *
+ * @param data the
+ * This method uses {@link String#getBytes()}.
+ *
+ * @param data the
+ * Character encoding names can be found at
+ * IANA.
+ *
+ * This method uses {@link String#getBytes(String)}.
+ *
+ * @param data the
+ * Character encoding names can be found at
+ * IANA.
+ *
+ * @param lines the lines to write, null entries produce blank lines
+ * @param lineEnding the line separator to use, null is system default
+ * @param output the
+ * This method buffers the input internally, so there is no need to use a
+ *
+ * Large streams (over 2GB) will return a bytes copied value of
+ *
+ * This method buffers the input internally, so there is no need to use a
+ *
+ * The buffer size is given by {@link #DEFAULT_BUFFER_SIZE}.
+ *
+ * @param input the
+ * This method uses the provided buffer, so there is no need to use a
+ *
+ *
+ * @param input the
+ * This method buffers the input internally, so there is no need to use a
+ *
+ * The buffer size is given by {@link #DEFAULT_BUFFER_SIZE}.
+ *
+ * @param input the
+ * This method uses the provided buffer, so there is no need to use a
+ *
+ *
+ * @param input the
+ * This method buffers the input internally, so there is no need to use a
+ *
+ * This method uses {@link InputStreamReader}.
+ *
+ * @param input the
+ * This method buffers the input internally, so there is no need to use a
+ *
+ * This method uses {@link InputStreamReader}.
+ *
+ * @param input the
+ * This method buffers the input internally, so there is no need to use a
+ *
+ * Character encoding names can be found at
+ * IANA.
+ *
+ * This method uses {@link InputStreamReader}.
+ *
+ * @param input the
+ * This method buffers the input internally, so there is no need to use a
+ *
+ * Large streams (over 2GB) will return a chars copied value of
+ *
+ * This method buffers the input internally, so there is no need to use a
+ *
+ * The buffer size is given by {@link #DEFAULT_BUFFER_SIZE}.
+ *
+ * @param input the
+ * This method uses the provided buffer, so there is no need to use a
+ *
+ *
+ * @param input the
+ * This method buffers the input internally, so there is no need to use a
+ *
+ * The buffer size is given by {@link #DEFAULT_BUFFER_SIZE}.
+ *
+ * @param input the
+ * This method uses the provided buffer, so there is no need to use a
+ *
+ *
+ * @param input the
+ * This method buffers the input internally, so there is no need to use a
+ *
+ * Due to the implementation of OutputStreamWriter, this method performs a
+ * flush.
+ *
+ * This method uses {@link OutputStreamWriter}.
+ *
+ * @param input the
+ * This method buffers the input internally, so there is no need to use a
+ *
+ * Due to the implementation of OutputStreamWriter, this method performs a
+ * flush.
+ *
+ * This method uses {@link OutputStreamWriter}.
+ *
+ * This method buffers the input internally, so there is no need to use a
+ *
+ * Character encoding names can be found at
+ * IANA.
+ *
+ * Due to the implementation of OutputStreamWriter, this method performs a
+ * flush.
+ *
+ * This method uses {@link OutputStreamWriter}.
+ *
+ * @param input the
+ * This method buffers the input internally using
+ *
+ * This method buffers the input internally using
+ *
+ * This method buffers the input internally using
+ *
+ * This allows for the possibility that {@link InputStream#skip(long)} may
+ * not skip as many bytes as requested (most likely because of reaching EOF).
+ *
+ * @param input stream to skip
+ * @param toSkip the number of bytes to skip
+ * @see InputStream#skip(long)
+ *
+ * no longer throws IOException if there is a problem reading the file
+ * no longer throws IllegalArgumentException if toSkip is negative
+ * no longer throws EOFException if the number of bytes skipped was incorrect
+ * @since 2.0
+ */
+ public static void skipFully(InputStream input, long toSkip) {
+ try {
+ if (toSkip < 0) {
+ throw new IllegalArgumentException("Bytes to skip must not be negative: " + toSkip);
+ }
+ long skipped = skip(input, toSkip);
+ if (skipped != toSkip) {
+ throw new EOFException("Bytes to skip: " + toSkip + " actual: " + skipped);
+ }
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Skip the requested number of characters or fail if there are not enough left.
+ *
+ * This allows for the possibility that {@link Reader#skip(long)} may
+ * not skip as many characters as requested (most likely because of reaching EOF).
+ *
+ * @param input stream to skip
+ * @param toSkip the number of characters to skip
+ * @see Reader#skip(long)
+ *
+ * no longer throws IOException if there is a problem reading the file
+ * no longer throws IllegalArgumentException if toSkip is negative
+ * no longer throws EOFException if the number of characters skipped was incorrect
+ * @since 2.0
+ */
+ public static void skipFully(Reader input, long toSkip) {
+ try {
+ long skipped = skip(input, toSkip);
+ if (skipped != toSkip) {
+ throw new EOFException("Chars to skip: " + toSkip + " actual: " + skipped);
+ }
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Read characters from an input character stream.
+ * This implementation guarantees that it will read as many characters
+ * as possible before giving up; this may not always be the case for
+ * subclasses of {@link Reader}.
+ *
+ * @param input where to read input from
+ * @param buffer destination
+ * @param offset inital offset into buffer
+ * @param length length to read, must be >= 0
+ * @return actual length read; may be less than requested if EOF was reached
+ * no longer throws IOException if a read error occurs
+ * @since 2.2
+ */
+ public static int read(Reader input, char[] buffer, int offset, int length) {
+ try {
+ if (length < 0) {
+ throw new IllegalArgumentException("Length must not be negative: " + length);
+ }
+ int remaining = length;
+ while (remaining > 0) {
+ int location = length - remaining;
+ int count = input.read(buffer, offset + location, remaining);
+ if (EOF == count) {
+ // EOF
+ break;
+ }
+ remaining -= count;
+ }
+ return length - remaining;
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Read characters from an input character stream.
+ * This implementation guarantees that it will read as many characters
+ * as possible before giving up; this may not always be the case for
+ * subclasses of {@link Reader}.
+ *
+ * @param input where to read input from
+ * @param buffer destination
+ * @return actual length read; may be less than requested if EOF was reached
+ * no longer throws IOException if a read error occurs
+ * @since 2.2
+ */
+ public static int read(Reader input, char[] buffer) {
+ try {
+ return read(input, buffer, 0, buffer.length);
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Read bytes from an input stream.
+ * This implementation guarantees that it will read as many bytes
+ * as possible before giving up; this may not always be the case for
+ * subclasses of {@link InputStream}.
+ *
+ * @param input where to read input from
+ * @param buffer destination
+ * @param offset inital offset into buffer
+ * @param length length to read, must be >= 0
+ * @return actual length read; may be less than requested if EOF was reached
+ * no longer throws IOException if a read error occurs
+ * @since 2.2
+ */
+ public static int read(InputStream input, byte[] buffer, int offset, int length) {
+ try {
+ if (length < 0) {
+ throw new IllegalArgumentException("Length must not be negative: " + length);
+ }
+ int remaining = length;
+ while (remaining > 0) {
+ int location = length - remaining;
+ int count = input.read(buffer, offset + location, remaining);
+ if (EOF == count) {
+ // EOF
+ break;
+ }
+ remaining -= count;
+ }
+ return length - remaining;
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Read bytes from an input stream.
+ * This implementation guarantees that it will read as many bytes
+ * as possible before giving up; this may not always be the case for
+ * subclasses of {@link InputStream}.
+ *
+ * @param input where to read input from
+ * @param buffer destination
+ * @return actual length read; may be less than requested if EOF was reached
+ * no longer throws IOException if a read error occurs
+ * @since 2.2
+ */
+ public static int read(InputStream input, byte[] buffer) {
+ try {
+ return read(input, buffer, 0, buffer.length);
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Read the requested number of characters or fail if there are not enough left.
+ *
+ * This allows for the possibility that {@link Reader#read(char[], int, int)} may
+ * not read as many characters as requested (most likely because of reaching EOF).
+ *
+ * @param input where to read input from
+ * @param buffer destination
+ * @param offset inital offset into buffer
+ * @param length length to read, must be >= 0
+ *
+ * no longer throws IOException if there is a problem reading the file
+ * no longer throws IllegalArgumentException if length is negative
+ * no longer throws EOFException if the number of characters read was incorrect
+ * @since 2.2
+ */
+ public static void readFully(Reader input, char[] buffer, int offset, int length) {
+ try {
+ int actual = read(input, buffer, offset, length);
+ if (actual != length) {
+ throw new EOFException("Length to read: " + length + " actual: " + actual);
+ }
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Read the requested number of characters or fail if there are not enough left.
+ *
+ * This allows for the possibility that {@link Reader#read(char[], int, int)} may
+ * not read as many characters as requested (most likely because of reaching EOF).
+ *
+ * @param input where to read input from
+ * @param buffer destination
+ *
+ * no longer throws IOException if there is a problem reading the file
+ * no longer throws IllegalArgumentException if length is negative
+ * no longer throws EOFException if the number of characters read was incorrect
+ * @since 2.2
+ */
+ public static void readFully(Reader input, char[] buffer) {
+ try {
+ readFully(input, buffer, 0, buffer.length);
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Read the requested number of bytes or fail if there are not enough left.
+ *
+ * This allows for the possibility that {@link InputStream#read(byte[], int, int)} may
+ * not read as many bytes as requested (most likely because of reaching EOF).
+ *
+ * @param input where to read input from
+ * @param buffer destination
+ * @param offset inital offset into buffer
+ * @param length length to read, must be >= 0
+ *
+ * no longer throws IOException if there is a problem reading the file
+ * no longer throws IllegalArgumentException if length is negative
+ * no longer throws EOFException if the number of bytes read was incorrect
+ * @since 2.2
+ */
+ public static void readFully(InputStream input, byte[] buffer, int offset, int length) {
+ try {
+ int actual = read(input, buffer, offset, length);
+ if (actual != length) {
+ throw new EOFException("Length to read: " + length + " actual: " + actual);
+ }
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Read the requested number of bytes or fail if there are not enough left.
+ *
+ * This allows for the possibility that {@link InputStream#read(byte[], int, int)} may
+ * not read as many bytes as requested (most likely because of reaching EOF).
+ *
+ * @param input where to read input from
+ * @param buffer destination
+ *
+ * no longer throws IOException if there is a problem reading the file
+ * no longer throws IllegalArgumentException if length is negative
+ * no longer throws EOFException if the number of bytes read was incorrect
+ * @since 2.2
+ */
+ public static void readFully(InputStream input, byte[] buffer) {
+ try {
+ readFully(input, buffer, 0, buffer.length);
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+}
diff --git a/lib/src/generated/java/org/apache/commons/io/input/UncheckedReversedLinesFileReader.java b/lib/src/generated/java/org/apache/commons/io/input/UncheckedReversedLinesFileReader.java
new file mode 100644
index 0000000..f2e4386
--- /dev/null
+++ b/lib/src/generated/java/org/apache/commons/io/input/UncheckedReversedLinesFileReader.java
@@ -0,0 +1,330 @@
+/*
+ * 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.commons.io.input;
+
+import org.apache.commons.io.Charsets;
+
+import java.io.*;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetEncoder;
+import java.nio.charset.UnsupportedCharsetException;
+
+/**
+ * Reads lines in a file reversely (similar to a BufferedReader, but starting at
+ * the last line). Useful for e.g. searching in log files.
+ *
+ * @since 2.2
+ */
+public class UncheckedReversedLinesFileReader implements Closeable {
+
+ private final int blockSize;
+
+ private final Charset encoding;
+
+ private final RandomAccessFile randomAccessFile;
+
+ private final long totalByteLength;
+
+ private final long totalBlockCount;
+
+ private final byte[][] newLineSequences;
+
+ private final int avoidNewlineSplitBufferSize;
+
+ private final int byteDecrement;
+
+ private FilePart currentFilePart;
+
+ private boolean trailingNewlineOfFileSkipped = false;
+
+ /**
+ * Creates a ReversedLinesFileReader with default block size of 4KB and the
+ * platform's default encoding.
+ *
+ * @param file
+ * the file to be read
+ * @throws IOException if an I/O error occurs
+ */
+ public UncheckedReversedLinesFileReader(final File file) throws IOException {
+ this(file, 4096, Charset.defaultCharset().toString());
+ }
+
+ /**
+ * Creates a ReversedLinesFileReader with the given block size and encoding.
+ *
+ * @param file
+ * the file to be read
+ * @param blockSize
+ * size of the internal buffer (for ideal performance this should
+ * match with the block size of the underlying file system).
+ * @param encoding
+ * the encoding of the file
+ * @throws IOException if an I/O error occurs
+ * @since 2.3
+ */
+ public UncheckedReversedLinesFileReader(final File file, final int blockSize, final Charset encoding) throws IOException {
+ this.blockSize = blockSize;
+ this.encoding = encoding;
+ randomAccessFile = new RandomAccessFile(file, "r");
+ totalByteLength = randomAccessFile.length();
+ int lastBlockLength = (int) (totalByteLength % blockSize);
+ if (lastBlockLength > 0) {
+ totalBlockCount = totalByteLength / blockSize + 1;
+ } else {
+ totalBlockCount = totalByteLength / blockSize;
+ if (totalByteLength > 0) {
+ lastBlockLength = blockSize;
+ }
+ }
+ currentFilePart = new FilePart(totalBlockCount, lastBlockLength, null);
+ // --- check & prepare encoding ---
+ Charset charset = Charsets.toCharset(encoding);
+ CharsetEncoder charsetEncoder = charset.newEncoder();
+ float maxBytesPerChar = charsetEncoder.maxBytesPerChar();
+ if (maxBytesPerChar == 1f) {
+ // all one byte encodings are no problem
+ byteDecrement = 1;
+ } else if (charset == Charset.forName("UTF-8")) {
+ // http://en.wikipedia.org/wiki/UTF-8
+ byteDecrement = 1;
+ } else if (charset == Charset.forName("Shift_JIS")) {
+ // http://www.herongyang.com/Unicode/JIS-Shift-JIS-Encoding.html
+ byteDecrement = 1;
+ } else if (charset == Charset.forName("UTF-16BE") || charset == Charset.forName("UTF-16LE")) {
+ // however byte order has to be specified
+ byteDecrement = 2;
+ } else if (charset == Charset.forName("UTF-16")) {
+ throw new UnsupportedEncodingException("For UTF-16, you need to specify the byte order (use UTF-16BE or UTF-16LE)");
+ } else {
+ throw new UnsupportedEncodingException("Encoding " + encoding + " is not supported yet (feel free to submit a patch)");
+ }
+ // NOTE: The new line sequences are matched in the order given, so it is important that \r\n is BEFORE \n
+ newLineSequences = new byte[][] { "\r\n".getBytes(encoding), "\n".getBytes(encoding), "\r".getBytes(encoding) };
+ avoidNewlineSplitBufferSize = newLineSequences[0].length;
+ }
+
+ /**
+ * Creates a ReversedLinesFileReader with the given block size and encoding.
+ *
+ * @param file
+ * the file to be read
+ * @param blockSize
+ * size of the internal buffer (for ideal performance this should
+ * match with the block size of the underlying file system).
+ * @param encoding
+ * the encoding of the file
+ * @throws IOException if an I/O error occurs
+ * @throws UnsupportedCharsetException
+ * thrown instead of {@link UnsupportedEncodingException} in version 2.2 if the encoding is not
+ * supported.
+ */
+ public UncheckedReversedLinesFileReader(final File file, final int blockSize, final String encoding) throws IOException {
+ this(file, blockSize, Charsets.toCharset(encoding));
+ }
+
+ /**
+ * Returns the lines of the file from bottom to top.
+ *
+ * @return the next line or null if the start of the file is reached
+ * no longer throws IOException if an I/O error occurs
+ */
+ public String readLine() {
+ try {
+ String line = currentFilePart.readLine();
+ while (line == null) {
+ currentFilePart = currentFilePart.rollOver();
+ if (currentFilePart != null) {
+ line = currentFilePart.readLine();
+ } else {
+ // no more fileparts: we're done, leave line set to null
+ break;
+ }
+ }
+ // aligned behaviour wiht BufferedReader that doesn't return a last, emtpy line
+ if ("".equals(line) && !trailingNewlineOfFileSkipped) {
+ trailingNewlineOfFileSkipped = true;
+ line = readLine();
+ }
+ return line;
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Closes underlying resources.
+ *
+ * no longer throws IOException if an I/O error occurs
+ */
+ public void close() {
+ try {
+ randomAccessFile.close();
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ private class FilePart {
+
+ private final long no;
+
+ private final byte[] data;
+
+ private byte[] leftOver;
+
+ private int currentLastBytePos;
+
+ /**
+ * ctor
+ * @param no the part number
+ * @param length its length
+ * @param leftOverOfLastFilePart remainder
+ * @throws IOException if there is a problem reading the file
+ */
+ private FilePart(final long no, final int length, final byte[] leftOverOfLastFilePart) throws IOException {
+ this.no = no;
+ int dataLength = length + (leftOverOfLastFilePart != null ? leftOverOfLastFilePart.length : 0);
+ this.data = new byte[dataLength];
+ final long off = (no - 1) * blockSize;
+ // read data
+ if (no > 0) /* file not empty */
+ {
+ randomAccessFile.seek(off);
+ final int countRead = randomAccessFile.read(data, 0, length);
+ if (countRead != length) {
+ throw new IllegalStateException("Count of requested bytes and actually read bytes don't match");
+ }
+ }
+ // copy left over part into data arr
+ if (leftOverOfLastFilePart != null) {
+ System.arraycopy(leftOverOfLastFilePart, 0, data, length, leftOverOfLastFilePart.length);
+ }
+ this.currentLastBytePos = data.length - 1;
+ this.leftOver = null;
+ }
+
+ /**
+ * Handles block rollover
+ *
+ * @return the new FilePart or null
+ * @throws IOException if there was a problem reading the file
+ */
+ private FilePart rollOver() throws IOException {
+ if (currentLastBytePos > -1) {
+ throw new IllegalStateException("Current currentLastCharPos unexpectedly positive... " + "last readLine() should have returned something! currentLastCharPos=" + currentLastBytePos);
+ }
+ if (no > 1) {
+ return new FilePart(no - 1, blockSize, leftOver);
+ } else {
+ // NO 1 was the last FilePart, we're finished
+ if (leftOver != null) {
+ throw new IllegalStateException("Unexpected leftover of the last block: leftOverOfThisFilePart=" + new String(leftOver, encoding));
+ }
+ return null;
+ }
+ }
+
+ /**
+ * Reads a line.
+ *
+ * @return the line or null
+ * @throws IOException if there is an error reading from the file
+ */
+ private String readLine() throws IOException {
+ String line = null;
+ int newLineMatchByteCount;
+ boolean isLastFilePart = no == 1;
+ int i = currentLastBytePos;
+ while (i > -1) {
+ if (!isLastFilePart && i < avoidNewlineSplitBufferSize) {
+ // take a few bytes to the next file part to avoid splitting of newlines
+ createLeftOver();
+ // skip last few bytes and leave it to the next file part
+ break;
+ }
+ // --- check for newline ---
+ if ((newLineMatchByteCount = getNewLineMatchByteCount(data, i)) > 0) /* found newline */
+ {
+ final int lineStart = i + 1;
+ int lineLengthBytes = currentLastBytePos - lineStart + 1;
+ if (lineLengthBytes < 0) {
+ throw new IllegalStateException("Unexpected negative line length=" + lineLengthBytes);
+ }
+ byte[] lineData = new byte[lineLengthBytes];
+ System.arraycopy(data, lineStart, lineData, 0, lineLengthBytes);
+ line = new String(lineData, encoding);
+ currentLastBytePos = i - newLineMatchByteCount;
+ // found line
+ break;
+ }
+ // --- move cursor ---
+ i -= byteDecrement;
+ // --- end of file part handling ---
+ if (i < 0) {
+ createLeftOver();
+ // end of file part
+ break;
+ }
+ }
+ // --- last file part handling ---
+ if (isLastFilePart && leftOver != null) {
+ // there will be no line break anymore, this is the first line of the file
+ line = new String(leftOver, encoding);
+ leftOver = null;
+ }
+ return line;
+ }
+
+ /**
+ * Creates the buffer containing any left over bytes.
+ */
+ private void createLeftOver() {
+ int lineLengthBytes = currentLastBytePos + 1;
+ if (lineLengthBytes > 0) {
+ // create left over for next block
+ leftOver = new byte[lineLengthBytes];
+ System.arraycopy(data, 0, leftOver, 0, lineLengthBytes);
+ } else {
+ leftOver = null;
+ }
+ currentLastBytePos = -1;
+ }
+
+ /**
+ * Finds the new-line sequence and return its length.
+ *
+ * @param data buffer to scan
+ * @param i start offset in buffer
+ * @return length of newline sequence or 0 if none found
+ */
+ private int getNewLineMatchByteCount(byte[] data, int i) {
+ for (byte[] newLineSequence : newLineSequences) {
+ boolean match = true;
+ for (int j = newLineSequence.length - 1; j >= 0; j--) {
+ int k = i + j - (newLineSequence.length - 1);
+ match &= k >= 0 && data[k] == newLineSequence[j];
+ }
+ if (match) {
+ return newLineSequence.length;
+ }
+ }
+ return 0;
+ }
+ }
+}
diff --git a/lib/src/main/java/eu/hinsch/spring/boot/actuator/logview/FileSystemFileProvider.java b/lib/src/main/java/eu/hinsch/spring/boot/actuator/logview/FileSystemFileProvider.java
index ba7f18c..f49e01b 100644
--- a/lib/src/main/java/eu/hinsch/spring/boot/actuator/logview/FileSystemFileProvider.java
+++ b/lib/src/main/java/eu/hinsch/spring/boot/actuator/logview/FileSystemFileProvider.java
@@ -2,7 +2,7 @@
import com.codepoetics.protonpack.StreamUtils;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.io.input.ReversedLinesFileReader;
+import org.apache.commons.io.input.UncheckedReversedLinesFileReader;
import java.io.File;
import java.io.FileInputStream;
@@ -75,21 +75,13 @@ private File getFile(Path folder, String filename) {
@Override
public void tailContent(Path folder, String filename, OutputStream stream, int lines) throws IOException {
- try (ReversedLinesFileReader reader = new ReversedLinesFileReader(getFile(folder, filename))) {
+ try (UncheckedReversedLinesFileReader reader = new UncheckedReversedLinesFileReader(getFile(folder, filename))) {
ListBufferedInputStream.
+ *
+ * @param input the InputStream to read from, not null
+ * @return the list of Strings, never null
+ * no longer throws NullPointerException if the input is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 1.1
+ */
+ public static ListInputStream as a list of Strings,
+ * one entry per line, using the specified character encoding.
+ * BufferedInputStream.
+ *
+ * @param input the InputStream to read from, not null
+ * @param encoding the encoding to use, null means platform default
+ * @return the list of Strings, never null
+ * no longer throws NullPointerException if the input is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 2.3
+ */
+ public static ListInputStream as a list of Strings,
+ * one entry per line, using the specified character encoding.
+ * BufferedInputStream.
+ *
+ * @param input the InputStream to read from, not null
+ * @param encoding the encoding to use, null means platform default
+ * @return the list of Strings, never null
+ * no longer throws NullPointerException if the input is null
+ * no longer throws IOException if an I/O error occurs
+ * no longer throws UnsupportedCharsetException
+ * thrown instead of {@link UnsupportedEncodingException} in version 2.2 if the encoding is not
+ * supported.
+ * @since 1.1
+ */
+ public static ListReader as a list of Strings,
+ * one entry per line.
+ * BufferedReader.
+ *
+ * @param input the Reader to read from, not null
+ * @return the list of Strings, never null
+ * no longer throws NullPointerException if the input is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 1.1
+ */
+ public static ListReader.
+ * LineIterator holds a reference to the open
+ * Reader specified here. When you have finished with the
+ * iterator you should close the reader to free internal resources.
+ * This can be done by closing the reader directly, or by calling
+ * {@link LineIterator#close()} or {@link LineIterator#closeQuietly(LineIterator)}.
+ *
+ * try {
+ * LineIterator it = IOUtils.lineIterator(reader);
+ * while (it.hasNext()) {
+ * String line = it.nextLine();
+ * /// do something with line
+ * }
+ * } finally {
+ * IOUtils.closeQuietly(reader);
+ * }
+ *
+ *
+ * @param reader the Reader to read from, not null
+ * @return an Iterator of the lines in the reader, never null
+ * @throws IllegalArgumentException if the reader is null
+ * @since 1.2
+ */
+ public static LineIterator lineIterator(Reader reader) {
+ return new LineIterator(reader);
+ }
+
+ /**
+ * Return an Iterator for the lines in an InputStream, using
+ * the character encoding specified (or default encoding if null).
+ * LineIterator holds a reference to the open
+ * InputStream specified here. When you have finished with
+ * the iterator you should close the stream to free internal resources.
+ * This can be done by closing the stream directly, or by calling
+ * {@link LineIterator#close()} or {@link LineIterator#closeQuietly(LineIterator)}.
+ *
+ * try {
+ * LineIterator it = IOUtils.lineIterator(stream, charset);
+ * while (it.hasNext()) {
+ * String line = it.nextLine();
+ * /// do something with line
+ * }
+ * } finally {
+ * IOUtils.closeQuietly(stream);
+ * }
+ *
+ *
+ * @param input the InputStream to read from, not null
+ * @param encoding the encoding to use, null means platform default
+ * @return an Iterator of the lines in the reader, never null
+ * no longer throws IllegalArgumentException if the input is null
+ * no longer throws IOException if an I/O error occurs, such as if the encoding is invalid
+ * @since 2.3
+ */
+ public static LineIterator lineIterator(InputStream input, Charset encoding) {
+ try {
+ return new LineIterator(new InputStreamReader(input, Charsets.toCharset(encoding)));
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Return an Iterator for the lines in an InputStream, using
+ * the character encoding specified (or default encoding if null).
+ * LineIterator holds a reference to the open
+ * InputStream specified here. When you have finished with
+ * the iterator you should close the stream to free internal resources.
+ * This can be done by closing the stream directly, or by calling
+ * {@link LineIterator#close()} or {@link LineIterator#closeQuietly(LineIterator)}.
+ *
+ * try {
+ * LineIterator it = IOUtils.lineIterator(stream, "UTF-8");
+ * while (it.hasNext()) {
+ * String line = it.nextLine();
+ * /// do something with line
+ * }
+ * } finally {
+ * IOUtils.closeQuietly(stream);
+ * }
+ *
+ *
+ * @param input the InputStream to read from, not null
+ * @param encoding the encoding to use, null means platform default
+ * @return an Iterator of the lines in the reader, never null
+ * no longer throws IllegalArgumentException if the input is null
+ * no longer throws IOException if an I/O error occurs, such as if the encoding is invalid
+ * no longer throws UnsupportedCharsetException
+ * thrown instead of {@link UnsupportedEncodingException} in version 2.2 if the encoding is not
+ * supported.
+ * @since 1.2
+ */
+ public static LineIterator lineIterator(InputStream input, String encoding) {
+ try {
+ return lineIterator(input, Charsets.toCharset(encoding));
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Convert the specified CharSequence to an input stream, encoded as bytes
+ * using the default character encoding of the platform.
+ *
+ * @param input the CharSequence to convert
+ * @return an input stream
+ * @since 2.0
+ */
+ public static InputStream toInputStream(CharSequence input) {
+ return toInputStream(input, Charset.defaultCharset());
+ }
+
+ /**
+ * Convert the specified CharSequence to an input stream, encoded as bytes
+ * using the specified character encoding.
+ *
+ * @param input the CharSequence to convert
+ * @param encoding the encoding to use, null means platform default
+ * @return an input stream
+ * @since 2.3
+ */
+ public static InputStream toInputStream(CharSequence input, Charset encoding) {
+ return toInputStream(input.toString(), encoding);
+ }
+
+ /**
+ * Convert the specified CharSequence to an input stream, encoded as bytes
+ * using the specified character encoding.
+ * byte[] to an OutputStream.
+ *
+ * @param data the byte array to write, do not modify during output,
+ * null ignored
+ * @param output the OutputStream to write to
+ * no longer throws NullPointerException if output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 1.1
+ */
+ public static void write(byte[] data, OutputStream output) {
+ try {
+ if (data != null) {
+ output.write(data);
+ }
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Writes bytes from a byte[] to chars on a Writer
+ * using the default character encoding of the platform.
+ * Writer to write to
+ * no longer throws NullPointerException if output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 1.1
+ */
+ public static void write(byte[] data, Writer output) {
+ try {
+ write(data, output, Charset.defaultCharset());
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Writes bytes from a byte[] to chars on a Writer
+ * using the specified character encoding.
+ * Writer to write to
+ * @param encoding the encoding to use, null means platform default
+ * no longer throws NullPointerException if output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 2.3
+ */
+ public static void write(byte[] data, Writer output, Charset encoding) {
+ try {
+ if (data != null) {
+ output.write(new String(data, Charsets.toCharset(encoding)));
+ }
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Writes bytes from a byte[] to chars on a Writer
+ * using the specified character encoding.
+ * Writer to write to
+ * @param encoding the encoding to use, null means platform default
+ * no longer throws NullPointerException if output is null
+ * no longer throws IOException if an I/O error occurs
+ * no longer throws UnsupportedCharsetException
+ * thrown instead of {@link UnsupportedEncodingException} in version 2.2 if the encoding is not
+ * supported.
+ * @since 1.1
+ */
+ public static void write(byte[] data, Writer output, String encoding) {
+ try {
+ write(data, output, Charsets.toCharset(encoding));
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ // write char[]
+ //-----------------------------------------------------------------------
+ /**
+ * Writes chars from a char[] to a Writer
+ * using the default character encoding of the platform.
+ *
+ * @param data the char array to write, do not modify during output,
+ * null ignored
+ * @param output the Writer to write to
+ * no longer throws NullPointerException if output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 1.1
+ */
+ public static void write(char[] data, Writer output) {
+ try {
+ if (data != null) {
+ output.write(data);
+ }
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Writes chars from a char[] to bytes on an
+ * OutputStream.
+ * OutputStream to write to
+ * no longer throws NullPointerException if output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 1.1
+ */
+ public static void write(char[] data, OutputStream output) {
+ try {
+ write(data, output, Charset.defaultCharset());
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Writes chars from a char[] to bytes on an
+ * OutputStream using the specified character encoding.
+ * OutputStream to write to
+ * @param encoding the encoding to use, null means platform default
+ * no longer throws NullPointerException if output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 2.3
+ */
+ public static void write(char[] data, OutputStream output, Charset encoding) {
+ try {
+ if (data != null) {
+ output.write(new String(data).getBytes(Charsets.toCharset(encoding)));
+ }
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Writes chars from a char[] to bytes on an
+ * OutputStream using the specified character encoding.
+ * OutputStream to write to
+ * @param encoding the encoding to use, null means platform default
+ * no longer throws NullPointerException if output is null
+ * no longer throws IOException if an I/O error occurs
+ * no longer throws UnsupportedCharsetException
+ * thrown instead of {@link UnsupportedEncodingException} in version 2.2 if the encoding is not
+ * supported.
+ * @since 1.1
+ */
+ public static void write(char[] data, OutputStream output, String encoding) {
+ try {
+ write(data, output, Charsets.toCharset(encoding));
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ // write CharSequence
+ //-----------------------------------------------------------------------
+ /**
+ * Writes chars from a CharSequence to a Writer.
+ *
+ * @param data the CharSequence to write, null ignored
+ * @param output the Writer to write to
+ * no longer throws NullPointerException if output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 2.0
+ */
+ public static void write(CharSequence data, Writer output) {
+ try {
+ if (data != null) {
+ write(data.toString(), output);
+ }
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Writes chars from a CharSequence to bytes on an
+ * OutputStream using the default character encoding of the
+ * platform.
+ * CharSequence to write, null ignored
+ * @param output the OutputStream to write to
+ * no longer throws NullPointerException if output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 2.0
+ */
+ public static void write(CharSequence data, OutputStream output) {
+ try {
+ write(data, output, Charset.defaultCharset());
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Writes chars from a CharSequence to bytes on an
+ * OutputStream using the specified character encoding.
+ * CharSequence to write, null ignored
+ * @param output the OutputStream to write to
+ * @param encoding the encoding to use, null means platform default
+ * no longer throws NullPointerException if output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 2.3
+ */
+ public static void write(CharSequence data, OutputStream output, Charset encoding) {
+ try {
+ if (data != null) {
+ write(data.toString(), output, encoding);
+ }
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Writes chars from a CharSequence to bytes on an
+ * OutputStream using the specified character encoding.
+ * CharSequence to write, null ignored
+ * @param output the OutputStream to write to
+ * @param encoding the encoding to use, null means platform default
+ * no longer throws NullPointerException if output is null
+ * no longer throws IOException if an I/O error occurs
+ * no longer throws UnsupportedCharsetException
+ * thrown instead of {@link UnsupportedEncodingException} in version 2.2 if the encoding is not
+ * supported.
+ * @since 2.0
+ */
+ public static void write(CharSequence data, OutputStream output, String encoding) {
+ try {
+ write(data, output, Charsets.toCharset(encoding));
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ // write String
+ //-----------------------------------------------------------------------
+ /**
+ * Writes chars from a String to a Writer.
+ *
+ * @param data the String to write, null ignored
+ * @param output the Writer to write to
+ * no longer throws NullPointerException if output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 1.1
+ */
+ public static void write(String data, Writer output) {
+ try {
+ if (data != null) {
+ output.write(data);
+ }
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Writes chars from a String to bytes on an
+ * OutputStream using the default character encoding of the
+ * platform.
+ * String to write, null ignored
+ * @param output the OutputStream to write to
+ * no longer throws NullPointerException if output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 1.1
+ */
+ public static void write(String data, OutputStream output) {
+ try {
+ write(data, output, Charset.defaultCharset());
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Writes chars from a String to bytes on an
+ * OutputStream using the specified character encoding.
+ * String to write, null ignored
+ * @param output the OutputStream to write to
+ * @param encoding the encoding to use, null means platform default
+ * no longer throws NullPointerException if output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 2.3
+ */
+ public static void write(String data, OutputStream output, Charset encoding) {
+ try {
+ if (data != null) {
+ output.write(data.getBytes(Charsets.toCharset(encoding)));
+ }
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Writes chars from a String to bytes on an
+ * OutputStream using the specified character encoding.
+ * String to write, null ignored
+ * @param output the OutputStream to write to
+ * @param encoding the encoding to use, null means platform default
+ * no longer throws NullPointerException if output is null
+ * no longer throws IOException if an I/O error occurs
+ * no longer throws UnsupportedCharsetException
+ * thrown instead of {@link UnsupportedEncodingException} in version 2.2 if the encoding is not
+ * supported.
+ * @since 1.1
+ */
+ public static void write(String data, OutputStream output, String encoding) {
+ try {
+ write(data, output, Charsets.toCharset(encoding));
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ // write StringBuffer
+ //-----------------------------------------------------------------------
+ /**
+ * Writes chars from a StringBuffer to a Writer.
+ *
+ * @param data the StringBuffer to write, null ignored
+ * @param output the Writer to write to
+ * no longer throws NullPointerException if output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 1.1
+ * @deprecated replaced by write(CharSequence, Writer)
+ */
+ @Deprecated
+ public static void write(StringBuffer data, Writer output) {
+ try {
+ if (data != null) {
+ output.write(data.toString());
+ }
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Writes chars from a StringBuffer to bytes on an
+ * OutputStream using the default character encoding of the
+ * platform.
+ * StringBuffer to write, null ignored
+ * @param output the OutputStream to write to
+ * no longer throws NullPointerException if output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 1.1
+ * @deprecated replaced by write(CharSequence, OutputStream)
+ */
+ @Deprecated
+ public static void write(StringBuffer data, OutputStream output) {
+ try {
+ write(data, output, (String) null);
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Writes chars from a StringBuffer to bytes on an
+ * OutputStream using the specified character encoding.
+ * StringBuffer to write, null ignored
+ * @param output the OutputStream to write to
+ * @param encoding the encoding to use, null means platform default
+ * no longer throws NullPointerException if output is null
+ * no longer throws IOException if an I/O error occurs
+ * no longer throws UnsupportedCharsetException
+ * thrown instead of {@link UnsupportedEncodingException} in version 2.2 if the encoding is not
+ * supported.
+ * @since 1.1
+ * @deprecated replaced by write(CharSequence, OutputStream, String)
+ */
+ @Deprecated
+ public static void write(StringBuffer data, OutputStream output, String encoding) {
+ try {
+ if (data != null) {
+ output.write(data.toString().getBytes(Charsets.toCharset(encoding)));
+ }
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ // writeLines
+ //-----------------------------------------------------------------------
+ /**
+ * Writes the toString() value of each item in a collection to
+ * an OutputStream line by line, using the default character
+ * encoding of the platform and the specified line ending.
+ *
+ * @param lines the lines to write, null entries produce blank lines
+ * @param lineEnding the line separator to use, null is system default
+ * @param output the OutputStream to write to, not null, not closed
+ * no longer throws NullPointerException if the output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 1.1
+ */
+ public static void writeLines(Collection lines, String lineEnding, OutputStream output) {
+ try {
+ writeLines(lines, lineEnding, output, Charset.defaultCharset());
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Writes the toString() value of each item in a collection to
+ * an OutputStream line by line, using the specified character
+ * encoding and the specified line ending.
+ *
+ * @param lines the lines to write, null entries produce blank lines
+ * @param lineEnding the line separator to use, null is system default
+ * @param output the OutputStream to write to, not null, not closed
+ * @param encoding the encoding to use, null means platform default
+ * no longer throws NullPointerException if the output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 2.3
+ */
+ public static void writeLines(Collection lines, String lineEnding, OutputStream output, Charset encoding) {
+ try {
+ if (lines == null) {
+ return;
+ }
+ if (lineEnding == null) {
+ lineEnding = LINE_SEPARATOR;
+ }
+ Charset cs = Charsets.toCharset(encoding);
+ for (Object line : lines) {
+ if (line != null) {
+ output.write(line.toString().getBytes(cs));
+ }
+ output.write(lineEnding.getBytes(cs));
+ }
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Writes the toString() value of each item in a collection to
+ * an OutputStream line by line, using the specified character
+ * encoding and the specified line ending.
+ * OutputStream to write to, not null, not closed
+ * @param encoding the encoding to use, null means platform default
+ * no longer throws NullPointerException if the output is null
+ * no longer throws IOException if an I/O error occurs
+ * no longer throws UnsupportedCharsetException
+ * thrown instead of {@link UnsupportedEncodingException} in version 2.2 if the encoding is not
+ * supported.
+ * @since 1.1
+ */
+ public static void writeLines(Collection lines, String lineEnding, OutputStream output, String encoding) {
+ try {
+ writeLines(lines, lineEnding, output, Charsets.toCharset(encoding));
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Writes the toString() value of each item in a collection to
+ * a Writer line by line, using the specified line ending.
+ *
+ * @param lines the lines to write, null entries produce blank lines
+ * @param lineEnding the line separator to use, null is system default
+ * @param writer the Writer to write to, not null, not closed
+ * no longer throws NullPointerException if the input is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 1.1
+ */
+ public static void writeLines(Collection lines, String lineEnding, Writer writer) {
+ try {
+ if (lines == null) {
+ return;
+ }
+ if (lineEnding == null) {
+ lineEnding = LINE_SEPARATOR;
+ }
+ for (Object line : lines) {
+ if (line != null) {
+ writer.write(line.toString());
+ }
+ writer.write(lineEnding);
+ }
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ // copy from InputStream
+ //-----------------------------------------------------------------------
+ /**
+ * Copy bytes from an InputStream to an
+ * OutputStream.
+ * BufferedInputStream.
+ * -1 after the copy has completed since the correct
+ * number of bytes cannot be returned as an int. For large streams
+ * use the copyLarge(InputStream, OutputStream) method.
+ *
+ * @param input the InputStream to read from
+ * @param output the OutputStream to write to
+ * @return the number of bytes copied, or -1 if > Integer.MAX_VALUE
+ * no longer throws NullPointerException if the input or output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 1.1
+ */
+ public static int copy(InputStream input, OutputStream output) {
+ try {
+ long count = copyLarge(input, output);
+ if (count > Integer.MAX_VALUE) {
+ return -1;
+ }
+ return (int) count;
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Copy bytes from a large (over 2GB) InputStream to an
+ * OutputStream.
+ * BufferedInputStream.
+ * InputStream to read from
+ * @param output the OutputStream to write to
+ * @return the number of bytes copied
+ * no longer throws NullPointerException if the input or output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 1.3
+ */
+ public static long copyLarge(InputStream input, OutputStream output) {
+ try {
+ return copyLarge(input, output, new byte[DEFAULT_BUFFER_SIZE]);
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Copy bytes from a large (over 2GB) InputStream to an
+ * OutputStream.
+ * BufferedInputStream.
+ * InputStream to read from
+ * @param output the OutputStream to write to
+ * @param buffer the buffer to use for the copy
+ * @return the number of bytes copied
+ * no longer throws NullPointerException if the input or output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 2.2
+ */
+ public static long copyLarge(InputStream input, OutputStream output, byte[] buffer) {
+ try {
+ long count = 0;
+ int n = 0;
+ while (EOF != (n = input.read(buffer))) {
+ output.write(buffer, 0, n);
+ count += n;
+ }
+ return count;
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Copy some or all bytes from a large (over 2GB) InputStream to an
+ * OutputStream, optionally skipping input bytes.
+ * BufferedInputStream.
+ * InputStream to read from
+ * @param output the OutputStream to write to
+ * @param inputOffset : number of bytes to skip from input before copying
+ * -ve values are ignored
+ * @param length : number of bytes to copy. -ve means all
+ * @return the number of bytes copied
+ * no longer throws NullPointerException if the input or output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 2.2
+ */
+ public static long copyLarge(InputStream input, OutputStream output, long inputOffset, long length) {
+ try {
+ return copyLarge(input, output, inputOffset, length, new byte[DEFAULT_BUFFER_SIZE]);
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Copy some or all bytes from a large (over 2GB) InputStream to an
+ * OutputStream, optionally skipping input bytes.
+ * BufferedInputStream.
+ * InputStream to read from
+ * @param output the OutputStream to write to
+ * @param inputOffset : number of bytes to skip from input before copying
+ * -ve values are ignored
+ * @param length : number of bytes to copy. -ve means all
+ * @param buffer the buffer to use for the copy
+ *
+ * @return the number of bytes copied
+ * no longer throws NullPointerException if the input or output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 2.2
+ */
+ public static long copyLarge(InputStream input, OutputStream output, final long inputOffset, final long length, byte[] buffer) {
+ try {
+ if (inputOffset > 0) {
+ skipFully(input, inputOffset);
+ }
+ if (length == 0) {
+ return 0;
+ }
+ final int bufferLength = buffer.length;
+ int bytesToRead = bufferLength;
+ if (length > 0 && length < bufferLength) {
+ bytesToRead = (int) length;
+ }
+ int read;
+ long totalRead = 0;
+ while (bytesToRead > 0 && EOF != (read = input.read(buffer, 0, bytesToRead))) {
+ output.write(buffer, 0, read);
+ totalRead += read;
+ if (length > 0) {
+ // Note the cast must work because buffer.length is an integer
+ bytesToRead = (int) Math.min(length - totalRead, bufferLength);
+ }
+ }
+ return totalRead;
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Copy bytes from an InputStream to chars on a
+ * Writer using the default character encoding of the platform.
+ * BufferedInputStream.
+ * InputStream to read from
+ * @param output the Writer to write to
+ * no longer throws NullPointerException if the input or output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 1.1
+ */
+ public static void copy(InputStream input, Writer output) {
+ try {
+ copy(input, output, Charset.defaultCharset());
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Copy bytes from an InputStream to chars on a
+ * Writer using the specified character encoding.
+ * BufferedInputStream.
+ * InputStream to read from
+ * @param output the Writer to write to
+ * @param encoding the encoding to use, null means platform default
+ * no longer throws NullPointerException if the input or output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 2.3
+ */
+ public static void copy(InputStream input, Writer output, Charset encoding) {
+ try {
+ InputStreamReader in = new InputStreamReader(input, Charsets.toCharset(encoding));
+ copy(in, output);
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Copy bytes from an InputStream to chars on a
+ * Writer using the specified character encoding.
+ * BufferedInputStream.
+ * InputStream to read from
+ * @param output the Writer to write to
+ * @param encoding the encoding to use, null means platform default
+ * no longer throws NullPointerException if the input or output is null
+ * no longer throws IOException if an I/O error occurs
+ * no longer throws UnsupportedCharsetException
+ * thrown instead of {@link UnsupportedEncodingException} in version 2.2 if the encoding is not
+ * supported.
+ * @since 1.1
+ */
+ public static void copy(InputStream input, Writer output, String encoding) {
+ try {
+ copy(input, output, Charsets.toCharset(encoding));
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ // copy from Reader
+ //-----------------------------------------------------------------------
+ /**
+ * Copy chars from a Reader to a Writer.
+ * BufferedReader.
+ * -1 after the copy has completed since the correct
+ * number of chars cannot be returned as an int. For large streams
+ * use the copyLarge(Reader, Writer) method.
+ *
+ * @param input the Reader to read from
+ * @param output the Writer to write to
+ * @return the number of characters copied, or -1 if > Integer.MAX_VALUE
+ * no longer throws NullPointerException if the input or output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 1.1
+ */
+ public static int copy(Reader input, Writer output) {
+ try {
+ long count = copyLarge(input, output);
+ if (count > Integer.MAX_VALUE) {
+ return -1;
+ }
+ return (int) count;
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Copy chars from a large (over 2GB) Reader to a Writer.
+ * BufferedReader.
+ * Reader to read from
+ * @param output the Writer to write to
+ * @return the number of characters copied
+ * no longer throws NullPointerException if the input or output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 1.3
+ */
+ public static long copyLarge(Reader input, Writer output) {
+ try {
+ return copyLarge(input, output, new char[DEFAULT_BUFFER_SIZE]);
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Copy chars from a large (over 2GB) Reader to a Writer.
+ * BufferedReader.
+ * Reader to read from
+ * @param output the Writer to write to
+ * @param buffer the buffer to be used for the copy
+ * @return the number of characters copied
+ * no longer throws NullPointerException if the input or output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 2.2
+ */
+ public static long copyLarge(Reader input, Writer output, char[] buffer) {
+ try {
+ long count = 0;
+ int n = 0;
+ while (EOF != (n = input.read(buffer))) {
+ output.write(buffer, 0, n);
+ count += n;
+ }
+ return count;
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Copy some or all chars from a large (over 2GB) InputStream to an
+ * OutputStream, optionally skipping input chars.
+ * BufferedReader.
+ * Reader to read from
+ * @param output the Writer to write to
+ * @param inputOffset : number of chars to skip from input before copying
+ * -ve values are ignored
+ * @param length : number of chars to copy. -ve means all
+ * @return the number of chars copied
+ * no longer throws NullPointerException if the input or output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 2.2
+ */
+ public static long copyLarge(Reader input, Writer output, final long inputOffset, final long length) {
+ try {
+ return copyLarge(input, output, inputOffset, length, new char[DEFAULT_BUFFER_SIZE]);
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Copy some or all chars from a large (over 2GB) InputStream to an
+ * OutputStream, optionally skipping input chars.
+ * BufferedReader.
+ * Reader to read from
+ * @param output the Writer to write to
+ * @param inputOffset : number of chars to skip from input before copying
+ * -ve values are ignored
+ * @param length : number of chars to copy. -ve means all
+ * @param buffer the buffer to be used for the copy
+ * @return the number of chars copied
+ * no longer throws NullPointerException if the input or output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 2.2
+ */
+ public static long copyLarge(Reader input, Writer output, final long inputOffset, final long length, char[] buffer) {
+ try {
+ if (inputOffset > 0) {
+ skipFully(input, inputOffset);
+ }
+ if (length == 0) {
+ return 0;
+ }
+ int bytesToRead = buffer.length;
+ if (length > 0 && length < buffer.length) {
+ bytesToRead = (int) length;
+ }
+ int read;
+ long totalRead = 0;
+ while (bytesToRead > 0 && EOF != (read = input.read(buffer, 0, bytesToRead))) {
+ output.write(buffer, 0, read);
+ totalRead += read;
+ if (length > 0) {
+ // Note the cast must work because buffer.length is an integer
+ bytesToRead = (int) Math.min(length - totalRead, buffer.length);
+ }
+ }
+ return totalRead;
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Copy chars from a Reader to bytes on an
+ * OutputStream using the default character encoding of the
+ * platform, and calling flush.
+ * BufferedReader.
+ * Reader to read from
+ * @param output the OutputStream to write to
+ * no longer throws NullPointerException if the input or output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 1.1
+ */
+ public static void copy(Reader input, OutputStream output) {
+ try {
+ copy(input, output, Charset.defaultCharset());
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Copy chars from a Reader to bytes on an
+ * OutputStream using the specified character encoding, and
+ * calling flush.
+ * BufferedReader.
+ * Reader to read from
+ * @param output the OutputStream to write to
+ * @param encoding the encoding to use, null means platform default
+ * no longer throws NullPointerException if the input or output is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 2.3
+ */
+ public static void copy(Reader input, OutputStream output, Charset encoding) {
+ try {
+ OutputStreamWriter out = new OutputStreamWriter(output, Charsets.toCharset(encoding));
+ copy(input, out);
+ // we have to flush here.
+ out.flush();
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Copy chars from a Reader to bytes on an
+ * OutputStream using the specified character encoding, and
+ * calling flush.
+ * BufferedReader.
+ * Reader to read from
+ * @param output the OutputStream to write to
+ * @param encoding the encoding to use, null means platform default
+ * no longer throws NullPointerException if the input or output is null
+ * no longer throws IOException if an I/O error occurs
+ * no longer throws UnsupportedCharsetException
+ * thrown instead of {@link UnsupportedEncodingException} in version 2.2 if the encoding is not
+ * supported.
+ * @since 1.1
+ */
+ public static void copy(Reader input, OutputStream output, String encoding) {
+ try {
+ copy(input, output, Charsets.toCharset(encoding));
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ // content equals
+ //-----------------------------------------------------------------------
+ /**
+ * Compare the contents of two Streams to determine if they are equal or
+ * not.
+ * BufferedInputStream if they are not already buffered.
+ *
+ * @param input1 the first stream
+ * @param input2 the second stream
+ * @return true if the content of the streams are equal or they both don't
+ * exist, false otherwise
+ * no longer throws NullPointerException if either input is null
+ * no longer throws IOException if an I/O error occurs
+ */
+ public static boolean contentEquals(InputStream input1, InputStream input2) {
+ try {
+ if (!(input1 instanceof BufferedInputStream)) {
+ input1 = new BufferedInputStream(input1);
+ }
+ if (!(input2 instanceof BufferedInputStream)) {
+ input2 = new BufferedInputStream(input2);
+ }
+ int ch = input1.read();
+ while (EOF != ch) {
+ int ch2 = input2.read();
+ if (ch != ch2) {
+ return false;
+ }
+ ch = input1.read();
+ }
+ int ch2 = input2.read();
+ return ch2 == EOF;
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Compare the contents of two Readers to determine if they are equal or
+ * not.
+ * BufferedReader if they are not already buffered.
+ *
+ * @param input1 the first reader
+ * @param input2 the second reader
+ * @return true if the content of the readers are equal or they both don't
+ * exist, false otherwise
+ * no longer throws NullPointerException if either input is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 1.1
+ */
+ public static boolean contentEquals(Reader input1, Reader input2) {
+ try {
+ input1 = toBufferedReader(input1);
+ input2 = toBufferedReader(input2);
+ int ch = input1.read();
+ while (EOF != ch) {
+ int ch2 = input2.read();
+ if (ch != ch2) {
+ return false;
+ }
+ ch = input1.read();
+ }
+ int ch2 = input2.read();
+ return ch2 == EOF;
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Compare the contents of two Readers to determine if they are equal or
+ * not, ignoring EOL characters.
+ * BufferedReader if they are not already buffered.
+ *
+ * @param input1 the first reader
+ * @param input2 the second reader
+ * @return true if the content of the readers are equal (ignoring EOL differences), false otherwise
+ * no longer throws NullPointerException if either input is null
+ * no longer throws IOException if an I/O error occurs
+ * @since 2.2
+ */
+ public static boolean contentEqualsIgnoreEOL(Reader input1, Reader input2) {
+ try {
+ BufferedReader br1 = toBufferedReader(input1);
+ BufferedReader br2 = toBufferedReader(input2);
+ String line1 = br1.readLine();
+ String line2 = br2.readLine();
+ while (line1 != null && line2 != null && line1.equals(line2)) {
+ line1 = br1.readLine();
+ line2 = br2.readLine();
+ }
+ return line1 == null ? line2 == null ? true : false : line1.equals(line2);
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Skip bytes from an input byte stream.
+ * This implementation guarantees that it will read as many bytes
+ * as possible before giving up; this may not always be the case for
+ * subclasses of {@link Reader}.
+ *
+ * @param input byte stream to skip
+ * @param toSkip number of bytes to skip.
+ * @return number of bytes actually skipped.
+ *
+ * @see InputStream#skip(long)
+ *
+ * no longer throws IOException if there is a problem reading the file
+ * no longer throws IllegalArgumentException if toSkip is negative
+ * @since 2.0
+ */
+ public static long skip(InputStream input, long toSkip) {
+ try {
+ if (toSkip < 0) {
+ throw new IllegalArgumentException("Skip count must be non-negative, actual: " + toSkip);
+ }
+ /*
+ * N.B. no need to synchronize this because: - we don't care if the buffer is created multiple times (the data
+ * is ignored) - we always use the same size buffer, so if it it is recreated it will still be OK (if the buffer
+ * size were variable, we would need to synch. to ensure some other thread did not create a smaller one)
+ */
+ if (SKIP_BYTE_BUFFER == null) {
+ SKIP_BYTE_BUFFER = new byte[SKIP_BUFFER_SIZE];
+ }
+ long remain = toSkip;
+ while (remain > 0) {
+ long n = input.read(SKIP_BYTE_BUFFER, 0, (int) Math.min(remain, SKIP_BUFFER_SIZE));
+ if (n < 0) {
+ // EOF
+ break;
+ }
+ remain -= n;
+ }
+ return toSkip - remain;
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Skip characters from an input character stream.
+ * This implementation guarantees that it will read as many characters
+ * as possible before giving up; this may not always be the case for
+ * subclasses of {@link Reader}.
+ *
+ * @param input character stream to skip
+ * @param toSkip number of characters to skip.
+ * @return number of characters actually skipped.
+ *
+ * @see Reader#skip(long)
+ *
+ * no longer throws IOException if there is a problem reading the file
+ * no longer throws IllegalArgumentException if toSkip is negative
+ * @since 2.0
+ */
+ public static long skip(Reader input, long toSkip) {
+ try {
+ if (toSkip < 0) {
+ throw new IllegalArgumentException("Skip count must be non-negative, actual: " + toSkip);
+ }
+ /*
+ * N.B. no need to synchronize this because: - we don't care if the buffer is created multiple times (the data
+ * is ignored) - we always use the same size buffer, so if it it is recreated it will still be OK (if the buffer
+ * size were variable, we would need to synch. to ensure some other thread did not create a smaller one)
+ */
+ if (SKIP_CHAR_BUFFER == null) {
+ SKIP_CHAR_BUFFER = new char[SKIP_BUFFER_SIZE];
+ }
+ long remain = toSkip;
+ while (remain > 0) {
+ long n = input.read(SKIP_CHAR_BUFFER, 0, (int) Math.min(remain, SKIP_BUFFER_SIZE));
+ if (n < 0) {
+ // EOF
+ break;
+ }
+ remain -= n;
+ }
+ return toSkip - remain;
+ } catch (Exception e) {
+ throw new java.lang.RuntimeException("", e);
+ } finally {
+ }
+ }
+
+ /**
+ * Skip the requested number of bytes or fail if there are not enough left.
+ *