com.yahoo.io.IOUtils Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of vespajlib Show documentation
Show all versions of vespajlib Show documentation
Library for use in Java components of Vespa. Shared code which do
not fit anywhere else.
// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.io;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.UncheckedIOException;
import java.io.Writer;
import java.nio.channels.FileChannel;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.NoSuchFileException;
import java.util.List;
import java.nio.charset.Charset;
import java.nio.ByteBuffer;
/**
* Some static io convenience methods.
*
* @author bratseth
* @author Bjorn Borud
*/
public abstract class IOUtils {
static private final Charset utf8Charset = StandardCharsets.UTF_8;
/** Closes a writer, or does nothing if the writer is null */
public static void closeWriter(Writer writer) {
if (writer == null) return;
try { writer.close(); } catch (IOException e) {}
}
/** Closes a reader, or does nothing if the reader is null */
public static void closeReader(Reader reader) {
if (reader == null) return;
try { reader.close(); } catch (IOException e) {}
}
/** Closes an input stream, or does nothing if the stream is null */
public static void closeInputStream(InputStream stream) {
if (stream == null) return;
try { stream.close(); } catch (IOException e) {}
}
/** Closes an output stream, or does nothing if the stream is null */
public static void closeOutputStream(OutputStream stream) {
if (stream == null) return;
try { stream.close(); } catch (IOException e) {}
}
/**
* Creates a buffered reader
*
* @param filename the name or path of the file
* @param encoding the encoding of the file, for instance "UTF-8"
*/
public static BufferedReader createReader(File filename, String encoding) throws IOException {
return new BufferedReader(new InputStreamReader(new FileInputStream(filename), encoding));
}
/**
* Creates a buffered reader
*
* @param filename the name or path of the file
* @param encoding the encoding of the file, for instance "UTF-8"
*/
public static BufferedReader createReader(String filename, String encoding) throws IOException {
return new BufferedReader(new InputStreamReader(new FileInputStream(filename), encoding));
}
/** Creates a buffered reader in the default encoding */
public static BufferedReader createReader(String filename) throws IOException {
return new BufferedReader(new FileReader(filename));
}
/**
* Creates a buffered writer,
* and the directories to contain it if they do not exist
*
* @param filename the name or path of the file
* @param encoding the encoding to use, for instance "UTF-8"
* @param append whether to append to the files if it exists
*/
public static BufferedWriter createWriter(String filename, String encoding, boolean append) throws IOException {
createDirectory(filename);
return new BufferedWriter(new OutputStreamWriter(new FileOutputStream(filename, append), encoding));
}
/**
* Creates a buffered writer,
* and the directories to contain it if they do not exist
*
* @param file the file to write to
* @param encoding the encoding to use, for instance "UTF-8"
* @param append whether to append to the files if it exists
*/
public static BufferedWriter createWriter(File file, String encoding, boolean append) throws IOException {
createDirectory(file.getAbsolutePath());
return new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file, append),encoding));
}
/**
* Creates a buffered writer in the default encoding
*
* @param filename the name or path of the file
* @param append whether to append to the files if it exists
*/
public static BufferedWriter createWriter(String filename, boolean append) throws IOException {
createDirectory(filename);
return new BufferedWriter(new FileWriter(filename, append));
}
/**
* Creates a buffered writer in the default encoding
*
* @param file the file to write to
* @param append whether to append to the files if it exists
*/
public static BufferedWriter createWriter(File file, boolean append) throws IOException {
createDirectory(file.getAbsolutePath());
return new BufferedWriter(new FileWriter(file, append));
}
/** Creates the directory path of this file if it does not exist */
public static void createDirectory(String filename) {
File directory = new File(filename).getParentFile();
if (directory != null)
directory.mkdirs();
}
/**
* Copies the n first lines of a file to another file.
* If the out file exists it will be overwritten
*
* @throws IOException if copying fails
*/
public static void copy(String inFile, String outFile, int lineCount) throws IOException {
BufferedReader reader = null;
BufferedWriter writer = null;
try {
reader = createReader(inFile);
writer = createWriter(outFile, false);
int c;
int newLines = 0;
while (-1 != (c=reader.read()) && newLines 0) {
out.write(buf, 0, len);
}
}
finally {
closeInputStream(in);
closeOutputStream(out);
}
}
else if (maxRecurseLevel!=0) { // copy directory if allowed
if (!targetLocation.exists())
targetLocation.mkdirs();
String[] children = sourceLocation.list(filter);
for (int i=0; i getLines(String fileName) throws IOException {
BufferedReader reader = null;
try {
List lines = new java.util.ArrayList<>();
reader = createReader(fileName,"utf8");
String line;
while (null != (line = reader.readLine()))
lines.add(line);
return lines;
} finally {
closeReader(reader);
}
}
/**
* Recursive deletion of directories
*/
public static boolean recursiveDeleteDir(File dir) {
if (dir.isDirectory()) {
String[] children = dir.list();
for (String child : children) {
boolean success = recursiveDeleteDir(new File(dir, child));
if (!success) return false;
}
}
// The directory is now empty so delete it
return dir.delete();
}
/**
* Encodes string as UTF-8 into ByteBuffer
*/
public static ByteBuffer utf8ByteBuffer(String s) {
return utf8Charset.encode(s);
}
/**
* Reads the contents of a UTF-8 text file into a String.
*
* @param file the file to read, or null
* @return the file content as a string, or null if the input file was null
*/
public static String readFile(File file) throws IOException {
try {
if (file == null) return null;
return Files.readString(file.toPath(), utf8Charset);
}
catch (NoSuchFileException e) {
throw new NoSuchFileException("Could not find file '" + file.getAbsolutePath() + "'");
}
}
/**
* Reads all the content of the given input stream, in chunks of at max chunkSize
*/
public static byte[] readBytes(InputStream stream, int chunkSize) throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
int nRead;
byte[] data = new byte[chunkSize];
while ((nRead = stream.read(data, 0, data.length)) != -1)
buffer.write(data, 0, nRead);
buffer.flush();
return buffer.toByteArray();
}
/**
* Reads the content of a file into a byte array
*/
public static byte[] readFileBytes(File file) throws IOException {
long lengthL = file.length();
if (lengthL>Integer.MAX_VALUE)
throw new IllegalArgumentException("File too big for byte array: "+file.getCanonicalPath());
try (InputStream in = new FileInputStream(file)) {
int length = (int)lengthL;
byte[] array = new byte[length];
int offset = 0;
int count=0;
while (offset < length && (count = in.read(array, offset, (length - offset)))>=0)
offset += count;
return array;
}
}
/**
* Reads all data from a reader into a string. Uses a buffer to speed up reading.
*/
public static String readAll(Reader reader) throws IOException {
StringBuilder sb = new StringBuilder();
try (BufferedReader buffered = new BufferedReader(reader)) {
int c;
while ((c = buffered.read()) != -1)
sb.appendCodePoint(c);
}
return sb.toString();
}
/** Read an input stream completely into a string */
public static String readAll(InputStream stream, Charset charset) throws IOException {
return new String(stream.readAllBytes(), charset);
}
/** Convenience method for closing a list of readers. Does nothing if the given reader list is null. */
public static void closeAll(List readers) {
if (readers==null) return;
for (Reader reader : readers)
closeReader(reader);
}
/**
* Writes the given string to the file
*/
public static void writeFile(File file, String text, boolean append) throws IOException {
BufferedWriter out = null;
try {
out = createWriter(file, append);
out.write(text);
}
finally {
closeWriter(out);
}
}
/** Writes the given content to the file (replacing any existing content) */
public static void writeFile(File file, byte[] content) throws UncheckedIOException {
try (FileOutputStream out = new FileOutputStream(file)) {
out.write(content);
}
catch (IOException e) {
throw new UncheckedIOException(e);
}
}
/**
* Writes the given string to the file
*/
public static void writeFile(String file, String text, boolean append) throws IOException {
writeFile(new File(file), text, append);
}
}