public static CharBuf read(Reader input, CharBuf charBuf, final int bufSize) {
if (charBuf == null) {
charBuf = CharBuf.create(bufSize);
} else {
charBuf.readForRecycle();
}
try {
char[] buffer = charBuf.toCharArray();
int size = input.read(buffer);
if (size != -1) {
charBuf._len(size);
}
if (size < buffer.length) {
return charBuf;
}
copy(input, charBuf);
} catch (IOException e) {
Exceptions.handle(e);
} finally {
try {
input.close();
} catch (IOException e) {
Exceptions.handle(e);
}
}
return charBuf;
}
/* End universal methods. */
private static int calculateIndex(float[] array, int originalIndex) {
final int length = array.length;
Exceptions.requireNonNull(array, "array cannot be null");
int index = originalIndex;
/* Adjust for reading from the right as in
-1 reads the 4th element if the length is 5
*/
if (index < 0) {
index = length + index;
}
/* Bounds check
if it is still less than 0, then they
have an negative index that is greater than length
*/
/* Bounds check
if it is still less than 0, then they
have an negative index that is greater than length
*/
if (index < 0) {
index = 0;
}
if (index >= length) {
index = length - 1;
}
return index;
}
public static float[] grow(float[] array, final int size) {
Exceptions.requireNonNull(array);
float[] newArray = new float[array.length + size];
System.arraycopy(array, 0, newArray, 0, array.length);
return newArray;
}
@Universal
public static float[] copy(float[] array) {
Exceptions.requireNonNull(array);
float[] newArray = new float[array.length];
System.arraycopy(array, 0, newArray, 0, array.length);
return newArray;
}
public static String read(File file) {
try (Reader reader = new FileReader(file)) {
return read(reader);
} catch (Exception ex) {
return Exceptions.handle(String.class, ex);
}
}
/**
* Double the size of an array.
*
* @param array the array you are going to double
* @return the new array with the old values copied in
*/
public static int[] grow(int[] array) {
Exceptions.requireNonNull(array);
int[] newArray = new int[array.length * 2];
System.arraycopy(array, 0, newArray, 0, array.length);
return newArray;
}
@Override
public <T> Supplier<T> getSupplier(final Class<T> type, final String name) {
ProviderInfo nullInfo = null;
try {
Set<ProviderInfo> set = Sets.set(supplierNameMap.getAll(name));
for (ProviderInfo info : set) {
if (info.type() == null) {
nullInfo = info;
continue;
}
if (type.isAssignableFrom(info.type())) {
return (Supplier<T>) info.supplier();
}
}
return (Supplier<T>)
(nullInfo != null
? nullInfo.supplier()
: new Supplier<T>() {
@Override
public T get() {
return null;
}
});
} catch (Exception e) {
Exceptions.handle(e);
return null;
}
}
public static String read(final String location) {
final URI uri = createURI(location);
return Exceptions.tryIt(
String.class,
new Exceptions.TrialWithReturn<String>() {
@Override
public String tryIt() throws Exception {
String path = location;
path = getWindowsPathIfNeeded(path);
if (uri.getScheme() == null) {
Path thePath = FileSystems.getDefault().getPath(path);
return read(Files.newBufferedReader(thePath, DEFAULT_CHARSET));
} else if (uri.getScheme().equals(FILE_SCHEMA)) {
return readFromFileSchema(uri);
} else if (uri.getScheme().equals(CLASSPATH_SCHEMA)
|| uri.getScheme().equals(JAR_SCHEMA)) {
return readFromClasspath(uri.toString());
} else {
return read(location, uri);
}
}
});
}
public static List<String> readLines(File file) {
try (FileReader reader = new FileReader(file)) {
return readLines(reader);
} catch (Exception ex) {
return Exceptions.handle(List.class, ex);
}
}
public static List<String> readLines(final String location) {
final String path = getWindowsPathIfNeeded(location);
final URI uri = createURI(path);
return (List<String>)
Exceptions.tryIt(
Typ.list,
new Exceptions.TrialWithReturn<List>() {
@Override
public List<String> tryIt() throws Exception {
if (uri.getScheme() == null) {
Path thePath = FileSystems.getDefault().getPath(path);
return Files.readAllLines(thePath, DEFAULT_CHARSET);
} else if (uri.getScheme().equals(FILE_SCHEMA)) {
Path thePath = FileSystems.getDefault().getPath(uri.getPath());
return Files.readAllLines(thePath, DEFAULT_CHARSET);
} else {
return readLines(location, uri);
}
}
});
}
public static byte[] input(String fileName) {
try {
return input(Files.newInputStream(IO.path(fileName)));
} catch (IOException e) {
return Exceptions.handle(byte[].class, e);
}
}
public static void eachLine(File file, EachLine eachLine) {
try (FileReader reader = new FileReader(file)) {
eachLine(reader, eachLine);
} catch (Exception ex) {
Exceptions.handle(List.class, ex);
}
}
public static InputStream inputStream(String resource) {
Path path = path(resource);
try {
return Files.newInputStream(path);
} catch (IOException e) {
return Exceptions.handle(InputStream.class, "unable to open " + resource, e);
}
}
public static void write(OutputStream out, String content, Charset charset) {
try (OutputStream o = out) {
o.write(content.getBytes(charset));
} catch (Exception ex) {
Exceptions.handle(ex);
}
}
public static void write(Path file, byte[] contents) {
try {
Files.write(file, contents);
} catch (Exception ex) {
Exceptions.handle(ex);
}
}
public static void writeNoClose(OutputStream out, String content) {
try {
out.write(content.getBytes(DEFAULT_CHARSET));
} catch (Exception ex) {
Exceptions.handle(ex);
}
}
public static float[] shrink(float[] array, int size) {
Exceptions.requireNonNull(array);
float[] newArray = new float[array.length - size];
System.arraycopy(array, 0, newArray, 0, array.length - size);
return newArray;
}
public static CharBuf read(InputStream inputStream, CharBuf charBuf, Charset charset) {
try (Reader reader = new InputStreamReader(inputStream, charset)) {
return read(reader, charBuf);
} catch (Exception ex) {
return Exceptions.handle(CharBuf.class, ex);
}
}
public static char[] readCharBuffer(InputStream inputStream) {
try (Reader reader = new InputStreamReader(inputStream)) {
return readCharBuffer(reader);
} catch (Exception ex) {
return Exceptions.handle(char[].class, ex);
}
}
public static String read(InputStream inputStream) {
try (Reader reader = new InputStreamReader(inputStream, DEFAULT_CHARSET)) {
return read(reader);
} catch (Exception ex) {
return Exceptions.handle(String.class, ex);
}
}
public static String readCharBuffer(InputStream inputStream, Charset charset) {
try (Reader reader = new InputStreamReader(inputStream, charset)) {
return read(reader);
} catch (Exception ex) {
return Exceptions.handle(String.class, ex);
}
}
public static String read(Path path) {
try {
return read(Files.newBufferedReader(path, DEFAULT_CHARSET));
} catch (IOException ex) {
return Exceptions.handle(String.class, ex);
}
}
private static String readFromFileSchema(URI uri) {
Path thePath = uriToPath(uri);
try {
return read(Files.newBufferedReader(thePath, DEFAULT_CHARSET));
} catch (IOException e) {
return Exceptions.handle(Typ.string, e); //
}
}
public static char[] readCharBuffer(Path path) {
try {
long bufSize = Files.size(path);
return readCharBuffer(Files.newBufferedReader(path, DEFAULT_CHARSET), (int) bufSize);
} catch (IOException ex) {
return Exceptions.handle(char[].class, ex);
}
}
public static String readChild(Path parentDir, String childFileName) {
try {
final Path newFilePath = path(parentDir.toString(), childFileName);
return read(newFilePath);
} catch (Exception ex) {
return Exceptions.handle(String.class, ex);
}
}
public static List<String> readLines(InputStream is) {
try (Reader reader = new InputStreamReader(is, DEFAULT_CHARSET)) {
return readLines(reader);
} catch (Exception ex) {
return Exceptions.handle(List.class, ex);
}
}
public static List<String> readLines(Reader reader) {
try (BufferedReader bufferedReader = new BufferedReader(reader)) {
return readLines(bufferedReader);
} catch (Exception ex) {
return Exceptions.handle(List.class, ex);
}
}
public static void writeChild(Path parentDir, String childFileName, String childContents) {
try {
final Path newFilePath = path(parentDir.toString(), childFileName);
write(newFilePath, childContents);
} catch (Exception ex) {
Exceptions.handle(ex);
}
}
public static void eachLine(Reader reader, EachLine eachLine) {
try (BufferedReader bufferedReader = new BufferedReader(reader)) {
eachLine(bufferedReader, eachLine);
} catch (Exception ex) {
Exceptions.handle(List.class, ex);
}
}
public static void eachLine(InputStream is, EachLine eachLine) {
try (Reader reader = new InputStreamReader(is, DEFAULT_CHARSET)) {
eachLine(reader, eachLine);
} catch (Exception ex) {
Exceptions.handle(ex);
}
}
