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

aQute.lib.io.IO Maven / Gradle / Ivy

Go to download

This framework extension fragment contains an extender that facilitates the use of JRE SPI providers (components typically plugged in to the JRE through META-INF/services resources).

There is a newer version: 1.3.7
Show newest version
package aQute.lib.io;

import static java.nio.charset.StandardCharsets.UTF_8;

import java.io.BufferedReader;
import java.io.Closeable;
import java.io.DataOutput;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.Channels;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.nio.channels.ReadableByteChannel;
import java.nio.channels.WritableByteChannel;
import java.nio.charset.Charset;
import java.nio.file.FileAlreadyExistsException;
import java.nio.file.FileVisitOption;
import java.nio.file.FileVisitResult;
import java.nio.file.FileVisitor;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.nio.file.StandardOpenOption;
import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.FileTime;
import java.security.MessageDigest;
import java.util.Collection;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import aQute.libg.glob.Glob;

public class IO {
	static final Pattern								WINDOWS_MACROS			= Pattern.compile("%([^%]+)%");
	static final int									BUFFER_SIZE				= IOConstants.PAGE_SIZE * 16;
	private static final int							DIRECT_MAP_THRESHOLD	= BUFFER_SIZE;
	private static final boolean						isWindows				= File.separatorChar == '\\';
	static final public File							work					= new File(
		System.getProperty("user.dir"));
	static final public File							home;
	private static final EnumSet	writeOptions			= EnumSet.of(StandardOpenOption.WRITE,
		StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);
	private static final EnumSet	readOptions				= EnumSet.of(StandardOpenOption.READ);

	static {
		EnvironmentCalculator hc = new EnvironmentCalculator(isWindows);
		home = hc.getHome();
	}

	public static String getExtension(String fileName, String deflt) {
		int n = fileName.lastIndexOf('.');
		if (n < 0)
			return deflt;

		return fileName.substring(n + 1);
	}

	public static Collection tree(File current) {
		Set files = new LinkedHashSet<>();
		traverse(files, current, null);
		return files;
	}

	public static Collection tree(File current, String glob) {
		Set files = new LinkedHashSet<>();
		traverse(files, current, glob == null ? null : new Glob(glob));
		return files;
	}

	private static void traverse(Collection files, File current, Glob glob) {
		if (current.isFile() && (glob == null || glob.matcher(current.getName())
			.matches())) {
			files.add(current);
		} else if (current.isDirectory()) {
			for (File sub : current.listFiles()) {
				traverse(files, sub, glob);
			}
		}
	}

	public static File copy(byte[] data, File file) throws IOException {
		copy(data, file.toPath());
		return file;
	}

	public static Path copy(byte[] data, Path path) throws IOException {
		try (FileChannel out = writeChannel(path)) {
			ByteBuffer bb = ByteBuffer.wrap(data);
			while (bb.hasRemaining()) {
				out.write(bb);
			}
		}
		return path;
	}

	public static Writer copy(byte[] data, Writer w) throws IOException {
		w.write(new String(data, 0, data.length, UTF_8));
		return w;
	}

	public static OutputStream copy(byte[] data, OutputStream out) throws IOException {
		out.write(data, 0, data.length);
		return out;
	}

	public static Writer copy(Reader r, Writer w) throws IOException {
		try {
			char[] buffer = new char[BUFFER_SIZE];
			for (int size; (size = r.read(buffer, 0, buffer.length)) > 0;) {
				w.write(buffer, 0, size);
			}
			return w;
		} finally {
			r.close();
		}
	}

	public static OutputStream copy(Reader r, OutputStream out) throws IOException {
		return copy(r, out, UTF_8);
	}

	public static OutputStream copy(Reader r, OutputStream out, String charset) throws IOException {
		return copy(r, out, Charset.forName(charset));
	}

	public static OutputStream copy(Reader r, OutputStream out, Charset charset) throws IOException {
		Writer w = writer(out, charset);
		try {
			copy(r, w);
			return out;
		} finally {
			w.flush();
		}
	}

	public static Writer copy(InputStream in, Writer w) throws IOException {
		return copy(in, w, UTF_8);
	}

	public static Writer copy(InputStream in, Writer w, String charset) throws IOException {
		return copy(in, w, Charset.forName(charset));
	}

	public static Writer copy(InputStream in, Writer w, Charset charset) throws IOException {
		return copy(reader(in, charset), w);
	}

	public static OutputStream copy(InputStream in, OutputStream out) throws IOException {
		try {
			byte[] buffer = new byte[BUFFER_SIZE];
			for (int size; (size = in.read(buffer, 0, buffer.length)) > 0;) {
				out.write(buffer, 0, size);
			}
			return out;
		} finally {
			in.close();
		}
	}

	public static ByteBufferOutputStream copy(InputStream in, ByteBufferOutputStream out) throws IOException {
		try {
			out.write(in);
			return out;
		} finally {
			in.close();
		}
	}

	public static DataOutput copy(InputStream in, DataOutput out) throws IOException {
		try {
			byte[] buffer = new byte[BUFFER_SIZE];
			for (int size; (size = in.read(buffer, 0, buffer.length)) > 0;) {
				out.write(buffer, 0, size);
			}
			return out;
		} finally {
			in.close();
		}
	}

	public static WritableByteChannel copy(ReadableByteChannel in, WritableByteChannel out) throws IOException {
		try {
			ByteBuffer bb = ByteBuffer.allocateDirect(BUFFER_SIZE);
			while (in.read(bb) > 0) {
				bb.flip();
				out.write(bb);
				bb.compact();
			}
			for (bb.flip(); bb.hasRemaining();) {
				out.write(bb);
			}
			return out;
		} finally {
			in.close();
		}
	}

	public static ByteBuffer copy(InputStream in, ByteBuffer bb) throws IOException {
		try {
			if (bb.hasArray()) {
				byte[] buffer = bb.array();
				int offset = bb.arrayOffset();
				for (int size, position; bb.hasRemaining()
					&& (size = in.read(buffer, offset + (position = bb.position()), bb.remaining())) > 0;) {
					bb.position(position + size);
				}
			} else {
				int length = Math.min(bb.remaining(), BUFFER_SIZE);
				byte[] buffer = new byte[length];
				for (int size; length > 0 && (size = in.read(buffer, 0, length)) > 0;) {
					bb.put(buffer, 0, size);
					length = Math.min(bb.remaining(), buffer.length);
				}
			}
			return bb;
		} finally {
			in.close();
		}
	}

	public static byte[] copy(InputStream in, byte[] data) throws IOException {
		return copy(in, data, 0, data.length);
	}

	public static byte[] copy(InputStream in, byte[] data, int off, int len) throws IOException {
		try {
			for (int remaining, size; (remaining = len - off) > 0 && (size = in.read(data, off, remaining)) > 0;) {
				off += size;
			}
			return data;
		} finally {
			in.close();
		}
	}

	public static OutputStream copy(ByteBuffer bb, OutputStream out) throws IOException {
		if (bb.hasArray()) {
			out.write(bb.array(), bb.arrayOffset() + bb.position(), bb.remaining());
			bb.position(bb.limit());
		} else {
			int length = Math.min(bb.remaining(), BUFFER_SIZE);
			byte[] buffer = new byte[length];
			while (length > 0) {
				bb.get(buffer, 0, length);
				out.write(buffer, 0, length);
				length = Math.min(bb.remaining(), buffer.length);
			}
		}
		return out;
	}

	public static MessageDigest copy(URL url, MessageDigest md) throws IOException {
		return copy(stream(url), md);
	}

	public static MessageDigest copy(File file, MessageDigest md) throws IOException {
		return copy(file.toPath(), md);
	}

	public static MessageDigest copy(Path path, MessageDigest md) throws IOException {
		return copy(readChannel(path), md);
	}

	public static MessageDigest copy(URLConnection conn, MessageDigest md) throws IOException {
		return copy(conn.getInputStream(), md);
	}

	public static MessageDigest copy(InputStream in, MessageDigest md) throws IOException {
		try {
			byte[] buffer = new byte[BUFFER_SIZE];
			for (int size; (size = in.read(buffer, 0, buffer.length)) > 0;) {
				md.update(buffer, 0, size);
			}
			return md;
		} finally {
			in.close();
		}
	}

	public static MessageDigest copy(ReadableByteChannel in, MessageDigest md) throws IOException {
		try {
			ByteBuffer bb = ByteBuffer.allocate(BUFFER_SIZE);
			while (in.read(bb) > 0) {
				bb.flip();
				md.update(bb);
				bb.compact();
			}
			for (bb.flip(); bb.hasRemaining();) {
				md.update(bb);
			}
			return md;
		} finally {
			in.close();
		}
	}

	public static File copy(URL url, File file) throws IOException {
		return copy(stream(url), file);
	}

	public static File copy(URLConnection conn, File file) throws IOException {
		return copy(conn.getInputStream(), file);
	}

	public static URL copy(InputStream in, URL url) throws IOException {
		return copy(in, url, null);
	}

	public static URL copy(InputStream in, URL url, String method) throws IOException {
		URLConnection c = url.openConnection();
		HttpURLConnection http = (c instanceof HttpURLConnection) ? (HttpURLConnection) c : null;
		if (http != null && method != null) {
			http.setRequestMethod(method);
		}
		c.setDoOutput(true);
		try (OutputStream out = c.getOutputStream()) {
			copy(in, out);
			return url;
		} finally {
			if (http != null) {
				http.disconnect();
			}
		}
	}

	public static File copy(File src, File tgt) throws IOException {
		copy(src.toPath(), tgt.toPath());
		return tgt;
	}

	public static Path copy(Path src, Path tgt) throws IOException {
		final Path source = src.toAbsolutePath();
		final Path target = tgt.toAbsolutePath();
		if (Files.isRegularFile(source)) {
			Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);
			return tgt;
		}
		if (Files.isDirectory(source)) {
			if (Files.notExists(target)) {
				mkdirs(target);
			}
			if (!Files.isDirectory(target))
				throw new IllegalArgumentException("target directory for a directory must be a directory: " + target);
			if (target.startsWith(source))
				throw new IllegalArgumentException("target directory can not be child of source directory.");

			Files.walkFileTree(source, EnumSet.of(FileVisitOption.FOLLOW_LINKS), Integer.MAX_VALUE,
				new FileVisitor() {
					final FileTime now = FileTime.fromMillis(System.currentTimeMillis());

					@Override
					public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
						Path targetdir = target.resolve(source.relativize(dir));
						try {
							Files.copy(dir, targetdir);
						} catch (FileAlreadyExistsException e) {
							if (!Files.isDirectory(targetdir))
								throw e;
						}
						return FileVisitResult.CONTINUE;
					}

					@Override
					public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
						Path targetFile = target.resolve(source.relativize(file));
						Files.copy(file, targetFile, StandardCopyOption.REPLACE_EXISTING);
						Files.setLastModifiedTime(targetFile, now);
						return FileVisitResult.CONTINUE;
					}

					@Override
					public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException {
						if (exc != null) { // directory iteration failed
							throw exc;
						}
						return FileVisitResult.CONTINUE;
					}

					@Override
					public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
						if (exc != null) {
							throw exc;
						}
						return FileVisitResult.CONTINUE;
					}
				});
			return tgt;
		}
		throw new FileNotFoundException("During copy: " + source.toString());
	}

	public static File copy(InputStream in, File file) throws IOException {
		copy(in, file.toPath());
		return file;
	}

	public static Path copy(InputStream in, Path path) throws IOException {
		try (FileChannel out = writeChannel(path)) {
			copy(in, out);
		}
		return path;
	}

	public static OutputStream copy(File file, OutputStream out) throws IOException {
		return copy(file.toPath(), out);
	}

	public static OutputStream copy(Path path, OutputStream out) throws IOException {
		return copy(readChannel(path), out);
	}

	public static WritableByteChannel copy(InputStream in, WritableByteChannel out) throws IOException {
		try {
			ByteBuffer bb = ByteBuffer.allocate(BUFFER_SIZE);
			byte[] buffer = bb.array();
			for (int size, position; (size = in.read(buffer, position = bb.position(), bb.remaining())) > 0;) {
				bb.position(position + size);
				bb.flip();
				out.write(bb);
				bb.compact();
			}
			for (bb.flip(); bb.hasRemaining();) {
				out.write(bb);
			}
			return out;
		} finally {
			in.close();
		}
	}

	public static OutputStream copy(ReadableByteChannel in, OutputStream out) throws IOException {
		try {
			ByteBuffer bb = ByteBuffer.allocate(BUFFER_SIZE);
			byte[] buffer = bb.array();
			for (; in.read(bb) > 0; bb.clear()) {
				out.write(buffer, 0, bb.position());
			}
			return out;
		} finally {
			in.close();
		}
	}

	public static byte[] read(File file) throws IOException {
		try (FileChannel in = readChannel(file.toPath())) {
			ByteBuffer bb = ByteBuffer.allocate((int) in.size());
			while (in.read(bb) > 0) {}
			return bb.array();
		}
	}

	public static ByteBuffer read(Path path) throws IOException {
		try (FileChannel in = readChannel(path)) {
			long size = in.size();
			if (!isWindows && (size > DIRECT_MAP_THRESHOLD)) {
				return in.map(MapMode.READ_ONLY, 0, size);
			}
			ByteBuffer bb = ByteBuffer.allocate((int) size);
			while (in.read(bb) > 0) {}
			bb.flip();
			return bb;
		}
	}

	public static byte[] read(ByteBuffer bb) {
		byte[] data = new byte[bb.remaining()];
		bb.get(data, 0, data.length);
		return data;
	}

	public static byte[] read(URL url) throws IOException {
		URLConnection conn = url.openConnection();
		conn.connect();
		int length = conn.getContentLength();
		if (length == -1) {
			return read(conn.getInputStream());
		}
		return copy(conn.getInputStream(), new byte[length]);
	}

	public static byte[] read(InputStream in) throws IOException {
		return copy(in, new ByteBufferOutputStream()).toByteArray();
	}

	public static void write(byte[] data, OutputStream out) throws Exception {
		copy(data, out);
	}

	public static void write(byte[] data, File file) throws Exception {
		copy(data, file);
	}

	public static String collect(File file) throws IOException {
		return collect(file.toPath(), UTF_8);
	}

	public static String collect(File file, String encoding) throws IOException {
		return collect(file.toPath(), Charset.forName(encoding));
	}

	public static String collect(File file, Charset encoding) throws IOException {
		return collect(file.toPath(), encoding);
	}

	public static String collect(Path path) throws IOException {
		return collect(path, UTF_8);
	}

	public static String collect(Path path, Charset encoding) throws IOException {
		return collect(reader(path, encoding));
	}

	public static String collect(ByteBuffer bb, Charset encoding) {
		return decode(bb, encoding).toString();
	}

	public static String collect(URL url, String encoding) throws IOException {
		return collect(stream(url), Charset.forName(encoding));
	}

	public static String collect(URL url, Charset encoding) throws IOException {
		return collect(stream(url), encoding);
	}

	public static String collect(URL url) throws IOException {
		return collect(url, UTF_8);
	}

	public static String collect(String path) throws IOException {
		return collect(Paths.get(path), UTF_8);
	}

	public static String collect(InputStream in) throws IOException {
		return collect(in, UTF_8);
	}

	public static String collect(InputStream in, String encoding) throws IOException {
		return collect(in, Charset.forName(encoding));
	}

	public static String collect(InputStream in, Charset encoding) throws IOException {
		return collect(reader(in, encoding));
	}

	public static String collect(Reader r) throws IOException {
		StringWriter w = new StringWriter();
		copy(r, w);
		return w.toString();
	}

	/**
	 * Create a temporary file.
	 *
	 * @param directory the directory in which to create the file. Can be null,
	 *            in which case the system TMP directory is used
	 * @param pattern the filename prefix pattern. Must be at least 3 characters
	 *            long
	 * @param suffix the filename suffix. Can be null, in which case (system)
	 *            default suffix is used
	 * @return temp file
	 * @throws IllegalArgumentException when pattern is null or too short
	 * @throws IOException when the specified (non-null) directory is not a
	 *             directory
	 */
	public static File createTempFile(File directory, String pattern, String suffix)
		throws IllegalArgumentException, IOException {
		if ((pattern == null) || (pattern.length() < 3)) {
			throw new IllegalArgumentException(
				"Pattern must be at least 3 characters long, got " + ((pattern == null) ? "null" : pattern.length()));
		}

		if ((directory != null) && !directory.isDirectory()) {
			throw new FileNotFoundException("Directory " + directory + " is not a directory");
		}

		return File.createTempFile(pattern, suffix, directory);
	}

	public static String absolutePath(File file) {
		return normalizePath(file.getAbsolutePath());
	}

	public static String absolutePath(Path path) {
		return normalizePath(path.toAbsolutePath());
	}

	public static String normalizePath(Path path) {
		return normalizePath(path.toString());
	}

	public static String normalizePath(File file) {
		return normalizePath(file.getPath());
	}

	public static String normalizePath(String path) {
		return path.replace(File.separatorChar, '/');
	}

	public static File getFile(String file) {
		return getFile(work, file);
	}

	public static File getFile(File base, String file) {
		if (file.startsWith("~/")) {
			file = file.substring(2);
			if (!file.startsWith("~/")) {
				return getFile(home, file);
			}
		}
		if (file.startsWith("~")) {
			file = file.substring(1);
			return getFile(home.getParentFile(), file);
		}

		File f = new File(file);
		if (f.isAbsolute()) {
			return f;
		}

		if (base == null) {
			base = work;
		}

		for (f = base.getAbsoluteFile(); !file.isEmpty();) {
			String first;
			int n = file.indexOf('/');
			if (n != -1) {
				first = file.substring(0, n);
				file = file.substring(n + 1);
			} else {
				first = file;
				file = "";
			}
			switch (first) {
				case "" :
				case "." :
					break;
				case ".." :
					File parent = f.getParentFile();
					if (parent != null) {
						f = parent;
					}
					break;
				default :
					f = new File(f, first);
					break;
			}
		}

		return f.getAbsoluteFile();
	}

	public static File getBasedFile(File base, String file) throws IOException {
		base = base.getCanonicalFile();
		File child = getFile(base, file);
		if (child.getCanonicalPath()
			.startsWith(base.getCanonicalPath())) {
			return child;
		}
		throw new IOException("The file " + child + " is outside of the base " + base);
	}

	public static Path getPath(String file) {
		return getPath(work.toPath(), file);
	}

	public static Path getPath(Path base, String file) {
		if (file.startsWith("~/")) {
			file = file.substring(2);
			if (!file.startsWith("~/")) {
				return getPath(home.toPath(), file);
			}
		}
		if (file.startsWith("~")) {
			file = file.substring(1);
			return getPath(home.toPath()
				.getParent(), file);
		}

		Path f = new File(file).toPath();
		if (f.isAbsolute()) {
			return f;
		}

		if (base == null) {
			base = work.toPath();
		}

		for (f = base.normalize()
			.toAbsolutePath(); !file.isEmpty();) {
			String first;
			int n = file.indexOf('/');
			if (n != -1) {
				first = file.substring(0, n);
				file = file.substring(n + 1);
			} else {
				first = file;
				file = "";
			}
			f = f.resolve(first)
				.normalize();
		}

		return f.toAbsolutePath();
	}

	public static Path getBasedPath(Path base, String file) throws IOException {
		base = base.normalize()
			.toAbsolutePath();
		Path child = getPath(base, file);
		if (child.startsWith(base)) {
			return child;
		}
		throw new IOException("The file " + child + " is outside of the base " + base);
	}

	/**
	 * Deletes the specified file. Folders are recursively deleted.
* If file(s) cannot be deleted, no feedback is provided (fail silently). * * @param file file to be deleted */ public static void delete(File file) { delete(file.toPath()); } /** * Deletes the specified path. Folders are recursively deleted.
* If file(s) cannot be deleted, no feedback is provided (fail silently). * * @param path path to be deleted */ public static void delete(Path path) { try { deleteWithException(path); } catch (IOException e) { // Ignore a failed delete } } /** * Deletes and creates directories */ public static void initialize(File dir) { try { deleteWithException(dir); mkdirs(dir); } catch (IOException e) { throw new RuntimeException(e); } } /** * Deletes the specified file. Folders are recursively deleted.
* Throws exception if any of the files could not be deleted. * * @param file file to be deleted * @throws IOException if the file (or contents of a folder) could not be * deleted */ public static void deleteWithException(File file) throws IOException { deleteWithException(file.toPath()); } /** * Deletes the specified path. Folders are recursively deleted.
* Throws exception if any of the files could not be deleted. * * @param path path to be deleted * @throws IOException if the path (or contents of a folder) could not be * deleted */ public static void deleteWithException(Path path) throws IOException { path = path.toAbsolutePath(); if (Files.notExists(path) && !isSymbolicLink(path)) { return; } if (path.equals(path.getRoot())) throw new IllegalArgumentException("Cannot recursively delete root for safety reasons"); Files.walkFileTree(path, new FileVisitor() { @Override public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException { return FileVisitResult.CONTINUE; } @Override public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException { Files.delete(file); return FileVisitResult.CONTINUE; } @Override public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException { try { Files.delete(file); } catch (IOException e) { throw exc; } return FileVisitResult.CONTINUE; } @Override public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException { if (exc != null) { // directory iteration failed throw exc; } Files.delete(dir); return FileVisitResult.CONTINUE; } }); } /** * Renames from to to replacing the target file if * necessary. * * @param from source file * @param to destination file * @throws IOException if the rename operation fails */ public static File rename(File from, File to) throws IOException { return rename(from.toPath(), to.toPath()).toFile(); } /** * Renames from to to replacing the target file if * necessary. * * @param from source path * @param to destination path * @throws IOException if the rename operation fails */ public static Path rename(Path from, Path to) throws IOException { return Files.move(from, to, StandardCopyOption.REPLACE_EXISTING); } public static File mkdirs(File dir) throws IOException { return mkdirs(dir.toPath()).toFile(); } public static Path mkdirs(Path dir) throws IOException { if (Files.isSymbolicLink(dir)) { return mkdirs(Files.readSymbolicLink(dir)); } return Files.createDirectories(dir); } public static long drain(InputStream in) throws IOException { try { long result = 0; byte[] buffer = new byte[BUFFER_SIZE]; for (int size; (size = in.read(buffer, 0, buffer.length)) > 0;) { result += size; } return result; } finally { in.close(); } } public static OutputStream copy(Collection c, OutputStream out) throws IOException { PrintWriter pw = writer(out); try { for (Object o : c) { pw.println(o); } return out; } finally { pw.flush(); } } public static Throwable close(Closeable in) { try { if (in != null) in.close(); } catch (Throwable e) { return e; } return null; } public static URL toURL(String s, File base) throws MalformedURLException { int n = s.indexOf(':'); if (n > 0 && n < 10) { // is url return new URL(s); } return getFile(base, s).toURI() .toURL(); } public static void store(Object o, File file) throws IOException { store(o, file.toPath(), UTF_8); } public static void store(Object o, File file, String encoding) throws IOException { store(o, file.toPath(), Charset.forName(encoding)); } public static void store(Object o, Path path, Charset encoding) throws IOException { try (FileChannel ch = writeChannel(path)) { if (o != null) { try (Writer w = Channels.newWriter(ch, encoding.newEncoder(), -1)) { w.write(o.toString()); } } } } public static void store(Object o, OutputStream out) throws IOException { store(o, out, UTF_8); } public static void store(Object o, OutputStream out, String encoding) throws IOException { store(o, out, Charset.forName(encoding)); } public static void store(Object o, OutputStream out, Charset encoding) throws IOException { Writer w = writer(out, encoding); try { store(o, w); } finally { w.flush(); } } public static void store(Object o, Writer w) throws IOException { if (o != null) { w.write(o.toString()); } } public static InputStream stream(byte[] data) { return stream(ByteBuffer.wrap(data)); } public static InputStream stream(ByteBuffer bb) { return new ByteBufferInputStream(bb); } public static InputStream stream(String s) { return stream(s, UTF_8); } public static InputStream stream(String s, String encoding) { return stream(s, Charset.forName(encoding)); } public static InputStream stream(String s, Charset encoding) { return stream(s.getBytes(encoding)); } public static InputStream stream(File file) throws IOException { return stream(file.toPath()); } public static InputStream stream(Path path) throws IOException { return Files.newInputStream(path); } public static InputStream stream(URL url) throws IOException { return url.openStream(); } public static FileChannel readChannel(Path path) throws IOException { return FileChannel.open(path, readOptions); } public static OutputStream outputStream(File file) throws IOException { return outputStream(file.toPath()); } public static OutputStream outputStream(Path path) throws IOException { return Files.newOutputStream(path); } public static FileChannel writeChannel(Path path) throws IOException { return FileChannel.open(path, writeOptions); } public static CharBuffer decode(ByteBuffer bb, Charset encoding) { return encoding.decode(bb); } public static ByteBuffer encode(CharBuffer cb, Charset encoding) { return encoding.encode(cb); } public static BufferedReader reader(String s) { return new BufferedReader(new StringReader(s)); } public static BufferedReader reader(File file) throws IOException { return reader(file.toPath(), UTF_8); } public static BufferedReader reader(File file, String encoding) throws IOException { return reader(file.toPath(), Charset.forName(encoding)); } public static BufferedReader reader(File file, Charset encoding) throws IOException { return reader(file.toPath(), encoding); } public static BufferedReader reader(Path path, Charset encoding) throws IOException { return reader(readChannel(path), encoding); } public static BufferedReader reader(ByteBuffer bb, Charset encoding) { return reader(new ByteBufferInputStream(bb), encoding); } public static BufferedReader reader(CharBuffer cb) { return new BufferedReader(new CharBufferReader(cb)); } public static BufferedReader reader(ReadableByteChannel in, Charset encoding) { return new BufferedReader(Channels.newReader(in, encoding.newDecoder(), -1)); } public static BufferedReader reader(InputStream in) { return reader(in, UTF_8); } public static BufferedReader reader(InputStream in, String encoding) { return reader(in, Charset.forName(encoding)); } public static BufferedReader reader(InputStream in, Charset encoding) { return new BufferedReader(new InputStreamReader(in, encoding)); } public static PrintWriter writer(File file) throws IOException { return writer(file.toPath(), UTF_8); } public static PrintWriter writer(File file, String encoding) throws IOException { return writer(file.toPath(), Charset.forName(encoding)); } public static PrintWriter writer(File file, Charset encoding) throws IOException { return writer(file.toPath(), encoding); } public static PrintWriter writer(Path path) throws IOException { return writer(path, UTF_8); } public static PrintWriter writer(Path path, Charset encoding) throws IOException { return writer(writeChannel(path), encoding); } public static PrintWriter writer(WritableByteChannel out, Charset encoding) { return new PrintWriter(Channels.newWriter(out, encoding.newEncoder(), -1)); } public static PrintWriter writer(OutputStream out) { return writer(out, UTF_8); } public static PrintWriter writer(OutputStream out, String encoding) { return writer(out, Charset.forName(encoding)); } public static PrintWriter writer(OutputStream out, Charset encoding) { return new PrintWriter(new OutputStreamWriter(out, encoding)); } public static boolean createSymbolicLink(File link, File target) throws Exception { return createSymbolicLink(link.toPath(), target.toPath()); } public static boolean createSymbolicLink(Path link, Path target) throws Exception { if (isSymbolicLink(link)) { Path linkTarget = Files.readSymbolicLink(link); if (target.equals(linkTarget)) { return true; } else { Files.delete(link); } } try { Files.createSymbolicLink(link, target); return true; } catch (Exception e) { // ignore } return false; } public static boolean isSymbolicLink(File link) { return isSymbolicLink(link.toPath()); } public static boolean isSymbolicLink(Path link) { return Files.isSymbolicLink(link); } /** * Creates a symbolic link from {@code link} to the {@code target}, or * copies {@code target} to {@code link} if running on Windows. *

* Creating symbolic links on Windows requires administrator permissions, so * copying is a safer fallback. Copy only happens if timestamp and and file * length are different than target * * @param link the location of the symbolic link, or destination of the * copy. * @param target the source of the symbolic link, or source of the copy. * @return {@code true} if the operation succeeds, {@code false} otherwise. */ public static boolean createSymbolicLinkOrCopy(File link, File target) { return createSymbolicLinkOrCopy(link.toPath(), target.toPath()); } /** * Creates a symbolic link from {@code link} to the {@code target}, or * copies {@code target} to {@code link} if running on Windows. *

* Creating symbolic links on Windows requires administrator permissions, so * copying is a safer fallback. Copy only happens if timestamp and and file * length are different than target * * @param link the location of the symbolic link, or destination of the * copy. * @param target the source of the symbolic link, or source of the copy. * @return {@code true} if the operation succeeds, {@code false} otherwise. */ public static boolean createSymbolicLinkOrCopy(Path link, Path target) { try { if (isWindows || !createSymbolicLink(link, target)) { // only copy if target length and timestamp differ BasicFileAttributes targetAttrs = Files.readAttributes(target, BasicFileAttributes.class); try { BasicFileAttributes linkAttrs = Files.readAttributes(link, BasicFileAttributes.class); if (targetAttrs.lastModifiedTime() .equals(linkAttrs.lastModifiedTime()) && targetAttrs.size() == linkAttrs.size()) { return true; } } catch (IOException e) { // link does not exist } copy(target, link); Files.setLastModifiedTime(link, targetAttrs.lastModifiedTime()); } return true; } catch (Exception ignore) { // ignore } return false; } static final public OutputStream nullStream = // new OutputStream() { @Override public void write(int var0) {} @Override public void write(byte[] var0) {} @Override public void write(byte[] var0, int from, int l) {} @Override public void close() {} @Override public void flush() {} }; static final public Writer nullWriter = // new Writer() { @Override public Writer append(char var0) { return this; } @Override public Writer append(CharSequence var0) { return this; } @Override public Writer append(CharSequence var0, int var1, int var2) { return this; } @Override public void write(int var0) {} @Override public void write(String var0) {} @Override public void write(String var0, int var1, int var2) {} @Override public void write(char[] var0) {} @Override public void write(char[] var0, int var1, int var2) {} @Override public void close() {} @Override public void flush() {} }; public static String toSafeFileName(String string) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < string.length(); i++) { char c = string.charAt(i); if (c < ' ') continue; if (isWindows) { switch (c) { case '<' : case '>' : case '"' : case '/' : case '\\' : case '|' : case '*' : case ':' : sb.append('%'); break; default : sb.append(c); } } else { switch (c) { case '/' : sb.append('%'); break; default : sb.append(c); } } } if (sb.length() == 0 || (isWindows && RESERVED_WINDOWS_P.matcher(sb) .matches())) sb.append("_"); return sb.toString(); } final static Pattern RESERVED_WINDOWS_P = Pattern.compile("CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9]"); public static boolean isWindows() { return isWindows; } /* * This class calculates the home path. This class uses environment * variables so that makes it hard to test. For this reason tests can * override the #getenv method. */ static class EnvironmentCalculator { private boolean iswindows; public EnvironmentCalculator(boolean iswindows) { this.iswindows = iswindows; } /** * Get the value of a system environment variable. Expand any macros * (%...%) if run on windows. Generally, on Linux et. al. environment * variables are already expanded. * * @param key the environment variable name * @return the value with expanded macros if on windows. */ String getSystemEnv(String key) { return getSystemEnv(key, null); } String getSystemEnv(String key, Set visited) { String value = getenv(key); if (value == null || !iswindows) { return value; } if (visited == null) { visited = new HashSet<>(); } else if (visited.contains(key)) return key; visited.add(key); StringBuffer sb = new StringBuffer(); Matcher matcher = WINDOWS_MACROS.matcher(value); int append = 0; while (matcher.find(append)) { String name = matcher.group(1); String replacement = getSystemEnv(name, visited); while (append < matcher.start()) { sb.append(value.charAt(append)); append++; } sb.append(replacement); append = matcher.end(); } while (append < value.length()) { sb.append(value.charAt(append)); append++; } return sb.toString(); } String getenv(String key) { return System.getenv(key); } File getHome() { File tmp = testFile(getSystemEnv("HOME")); if (tmp == null || !tmp.isDirectory()) { tmp = testFile(System.getProperty("user.home")); } assert tmp != null; return tmp; } File testFile(String path) { if (path == null) return null; return new File(path); } } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy