Java IoActions.withResource方法代码示例

import org.gradle.internal.IoActions; //导入方法依赖的package包/类
@Override
public org.gradle.api.java.archives.Manifest writeTo(Object path) {
    File manifestFile = fileResolver.resolve(path);
    try {
        File parentFile = manifestFile.getParentFile();
        if (parentFile != null) {
            FileUtils.forceMkdir(parentFile);
        }
        IoActions.withResource(new FileOutputStream(manifestFile), new Action<FileOutputStream>() {
            @Override
            public void execute(FileOutputStream fileOutputStream) {
                writeTo(fileOutputStream);
            }
        });
        return this;
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

import org.gradle.internal.IoActions; //导入方法依赖的package包/类
private static Trie readPrefixes(RuntimeShadedJarType type) {
    final Trie.Builder builder = new Trie.Builder();
    IoActions.withResource(ImplementationDependencyRelocator.class.getResourceAsStream(type.getIdentifier() + "-relocated.txt"), new ErroringAction<InputStream>() {
        @Override
        protected void doExecute(InputStream thing) throws Exception {
            BufferedReader reader = new BufferedReader(new InputStreamReader(thing, Charset.forName("UTF-8")));
            String line;
            while ((line = reader.readLine()) != null) {
                line = line.trim();
                if (line.length() > 0) {
                    builder.addWord(line);
                }
            }
        }
    });
    return builder.build();
}
 

import org.gradle.internal.IoActions; //导入方法依赖的package包/类
@Override
public void pack(final TaskOutputsInternal taskOutputs, OutputStream output, final TaskOutputOriginWriter writeOrigin) {
    IoActions.withResource(new TarOutputStream(output, "utf-8"), new Action<TarOutputStream>() {
        @Override
        public void execute(TarOutputStream outputStream) {
            outputStream.setLongFileMode(TarOutputStream.LONGFILE_POSIX);
            outputStream.setBigNumberMode(TarOutputStream.BIGNUMBER_POSIX);
            outputStream.setAddPaxHeadersForNonAsciiNames(true);
            try {
                packMetadata(writeOrigin, outputStream);
                pack(taskOutputs, outputStream);
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        }
    });
}
 

import org.gradle.internal.IoActions; //导入方法依赖的package包/类
public WorkResult execute(final CopyActionProcessingStream stream) {
    ZipOutputStream zipOutStr;

    try {
        zipOutStr = new ZipOutputStream(new FileOutputStream(zipFile));
    } catch (Exception e) {
        throw new GradleException(String.format("Could not create ZIP '%s'.", zipFile), e);
    }

    IoActions.withResource(zipOutStr, new Action<ZipOutputStream>() {
        public void execute(ZipOutputStream outputStream) {
            stream.process(new StreamAction(outputStream));
        }
    });

    return new SimpleWorkResult(true);
}
 

import org.gradle.internal.IoActions; //导入方法依赖的package包/类
private static void writeProbe(File workingDir) {
    File probeFile = new File(workingDir, JavaProbe.CLASSNAME + ".class");
    try {
        IoActions.withResource(new FileOutputStream(probeFile), new ErroringAction<FileOutputStream>() {
            @Override
            protected void doExecute(FileOutputStream thing) throws Exception {
                thing.write(JavaProbe.dump());
            }
        });
    } catch (FileNotFoundException e) {
        throw new GradleException("Unable to write Java probe file", e);
    }
}
 

import org.gradle.internal.IoActions; //导入方法依赖的package包/类
private void createFatJar(final File outputJar, final Iterable<? extends File> files, final ProgressLogger progressLogger) {
    final File tmpFile = tempFileFor(outputJar);

    IoActions.withResource(openJarOutputStream(tmpFile), new ErroringAction<ZipOutputStream>() {
        @Override
        protected void doExecute(ZipOutputStream jarOutputStream) throws Exception {
            processFiles(jarOutputStream, files, new byte[BUFFER_SIZE], new HashSet<String>(), new LinkedHashMap<String, List<String>>(), progressLogger);
            jarOutputStream.finish();
        }
    });

    GFileUtils.moveFile(tmpFile, outputJar);
}
 

import org.gradle.internal.IoActions; //导入方法依赖的package包/类
private void processJarFile(final ZipOutputStream outputStream, File file, final byte[] buffer, final Set<String> seenPaths, final Map<String, List<String>> services) throws IOException {
    IoActions.withResource(openJarFile(file), new ErroringAction<ZipInputStream>() {
        @Override
        protected void doExecute(ZipInputStream inputStream) throws Exception {
            ZipEntry zipEntry = inputStream.getNextEntry();
            while (zipEntry != null) {
                processEntry(outputStream, inputStream, zipEntry, buffer, seenPaths, services);
                zipEntry = inputStream.getNextEntry();
            }
        }
    });
}
 

import org.gradle.internal.IoActions; //导入方法依赖的package包/类
private void processJarFile(File file, final Trie.Builder builder) throws IOException {
    IoActions.withResource(openJarFile(file), new ErroringAction<ZipInputStream>() {
        @Override
        protected void doExecute(ZipInputStream inputStream) throws Exception {
            ZipEntry zipEntry = inputStream.getNextEntry();
            while (zipEntry != null) {
                processEntry(zipEntry, builder);
                zipEntry = inputStream.getNextEntry();
            }
        }
    });
}
 

import org.gradle.internal.IoActions; //导入方法依赖的package包/类
@Override
public void unpack(final TaskOutputsInternal taskOutputs, InputStream input, final TaskOutputOriginReader readOrigin) {
    IoActions.withResource(new TarInputStream(input), new Action<TarInputStream>() {
        @Override
        public void execute(TarInputStream tarInput) {
            try {
                unpack(taskOutputs, tarInput, readOrigin);
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        }
    });
}