import org.gradle.api.UncheckedIOException; //导入依赖的package包/类
@Deprecated
@Override
public DefaultManifest writeTo(Writer writer) {
    SingleMessageLogger.nagUserOfDeprecated("Manifest.writeTo(Writer)", "Please use Manifest.writeTo(Object) instead");
    try {
        Manifest javaManifest = generateJavaManifest(getEffectiveManifest());
        ByteArrayOutputStream buffer = new ByteArrayOutputStream();
        javaManifest.write(buffer);
        String manifestContent = buffer.toString(DEFAULT_CONTENT_CHARSET);
        if (!DEFAULT_CONTENT_CHARSET.equals(contentCharset)) {
            // Convert the UTF-8 manifest bytes to the requested content charset
            manifestContent = new String(manifestContent.getBytes(contentCharset), contentCharset);
        }
        writer.write(manifestContent);
        writer.flush();
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
    return this;
}
 

import org.gradle.api.UncheckedIOException; //导入依赖的package包/类
private void read(Object manifestPath) {
    File manifestFile = fileResolver.resolve(manifestPath);
    try {
        byte[] manifestBytes = FileUtils.readFileToByteArray(manifestFile);
        manifestBytes = prepareManifestBytesForInteroperability(manifestBytes);
        // Eventually convert manifest content to UTF-8 before handing it to java.util.jar.Manifest
        if (!DEFAULT_CONTENT_CHARSET.equals(contentCharset)) {
            manifestBytes = new String(manifestBytes, contentCharset).getBytes(DEFAULT_CONTENT_CHARSET);
        }
        // Effectively read the manifest
        Manifest javaManifest = new Manifest(new ByteArrayInputStream(manifestBytes));
        addJavaManifestToAttributes(javaManifest);
        addJavaManifestToSections(javaManifest);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

import org.gradle.api.UncheckedIOException; //导入依赖的package包/类
@TaskAction
void exec() {
  getProject().exec(new Action<ExecSpec>() {
    @Override
    public void execute(ExecSpec execSpec) {
      try {
        if (dexMergerExecutable == null) {
          dexMergerExecutable = Utils.dexMergerExecutable();
        }
        execSpec.setExecutable(dexMergerExecutable);
        execSpec.args(destination.getCanonicalPath());
        execSpec.args(source.getFiles());
      } catch (IOException e) {
        throw new UncheckedIOException(e);
      }
    }
  });
}
 

import org.gradle.api.UncheckedIOException; //导入依赖的package包/类
public static HashValue createHash(InputStream instr, String algorithm) {
    MessageDigest messageDigest;
    try {
        messageDigest = createMessageDigest(algorithm);
        byte[] buffer = new byte[4096];
        try {
            while (true) {
                int nread = instr.read(buffer);
                if (nread < 0) {
                    break;
                }
                messageDigest.update(buffer, 0, nread);
            }
        } finally {
            instr.close();
        }
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
    return new HashValue(messageDigest.digest());
}
 

import org.gradle.api.UncheckedIOException; //导入依赖的package包/类
public void execute(Action<? super BufferedWriter> action) {
    try {
        File parentFile = file.getParentFile();
        if (parentFile != null) {
            if (!parentFile.mkdirs() && !parentFile.isDirectory()) {
                throw new IOException(String.format("Unable to create directory '%s'", parentFile));
            }
        }
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), encoding));
        try {
            action.execute(writer);
        } finally {
            writer.close();
        }
    } catch (Exception e) {
        throw new UncheckedIOException(String.format("Could not write to file '%s'.", file), e);
    }
}
 

import org.gradle.api.UncheckedIOException; //导入依赖的package包/类
/**
 * Returns an args transformer that replaces the provided args with a generated args file containing the args. Uses platform text encoding.
 */
public static Transformer<List<String>, List<String>> argsFileGenerator(final File argsFile, final Transformer<ArgWriter, PrintWriter> argWriterFactory) {
    return new Transformer<List<String>, List<String>>() {
        @Override
        public List<String> transform(List<String> args) {
            if (args.isEmpty()) {
                return args;
            }
            argsFile.getParentFile().mkdirs();
            try {
                PrintWriter writer = new PrintWriter(argsFile);
                try {
                    ArgWriter argWriter = argWriterFactory.transform(writer);
                    argWriter.args(args);
                } finally {
                    writer.close();
                }
            } catch (IOException e) {
                throw new UncheckedIOException(String.format("Could not write options file '%s'.", argsFile.getAbsolutePath()), e);
            }
            return Collections.singletonList("@" + argsFile.getAbsolutePath());
        }
    };
}
 

import org.gradle.api.UncheckedIOException; //导入依赖的package包/类
public Properties create() {
    URL resource = classLoader.getResource(resourceName);
    if (resource == null) {
        throw new RuntimeException(
                "Unable to find the released versions information.\n"
                        + "The resource '" + resourceName + "' was not found.\n"
                        + "Most likely, you haven't run the 'prepareVersionsInfo' task.\n"
                        + "If you have trouble running tests from your IDE, please run gradlew idea|eclipse first."
        );
    }

    try {
        Properties properties = new Properties();
        InputStream stream = resource.openStream();
        try {
            properties.load(stream);
        } finally {
            stream.close();
        }
        return properties;
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

import org.gradle.api.UncheckedIOException; //导入依赖的package包/类
@Override
public boolean readFrom(Object path) {
    if (fileResolver == null) {
        return false;
    }
    File descriptorFile = fileResolver.resolve(path);
    if (descriptorFile == null || !descriptorFile.exists()) {
        return false;
    }
    try {
        FileReader reader = new FileReader(descriptorFile);
        readFrom(reader);
        return true;
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

import org.gradle.api.UncheckedIOException; //导入依赖的package包/类
public void printDaemonStarted(PrintStream target, Long pid, String uid, Address address, File daemonLog) {
    target.print(daemonGreeting());

    // Encode as ascii
    try {
        OutputStream outputStream = new EncodedStream.EncodedOutput(target);
        FlushableEncoder encoder = new OutputStreamBackedEncoder(outputStream);
        encoder.writeNullableString(pid == null ? null : pid.toString());
        encoder.writeString(uid);
        MultiChoiceAddress multiChoiceAddress = (MultiChoiceAddress) address;
        new MultiChoiceAddressSerializer().write(encoder, multiChoiceAddress);
        encoder.writeString(daemonLog.getPath());
        encoder.flush();
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }

    target.println();

    //ibm vm 1.6 + windows XP gotchas:
    //we need to print something else to the stream after we print the daemon greeting.
    //without it, the parent hangs without receiving the message above (flushing does not help).
    LOGGER.debug("Completed writing the daemon greeting. Closing streams...");
    //btw. the ibm vm+winXP also has some issues detecting closed streams by the child but we handle this problem differently.
}
 

import org.gradle.api.UncheckedIOException; //导入依赖的package包/类
public DaemonStartupInfo readDiagnostics(String message) {
    //Assuming the message has correct format. Not bullet proof, but seems to work ok for now.
    if (!message.startsWith(daemonGreeting())) {
        throw new IllegalArgumentException(String.format("Unexpected daemon startup message: %s", message));
    }
    try {
        String encoded = message.substring(daemonGreeting().length()).trim();
        InputStream inputStream = new EncodedStream.EncodedInput(new ByteArrayInputStream(encoded.getBytes()));
        Decoder decoder = new InputStreamBackedDecoder(inputStream);
        String pidString = decoder.readNullableString();
        String uid = decoder.readString();
        Long pid = pidString == null ? null : Long.valueOf(pidString);
        Address address = new MultiChoiceAddressSerializer().read(decoder);
        File daemonLog = new File(decoder.readString());
        return new DaemonStartupInfo(uid, address, new DaemonDiagnostics(daemonLog, pid));
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

import org.gradle.api.UncheckedIOException; //导入依赖的package包/类
private void maybeConfigureFrom(File propertiesFile, Map<String, String> result) {
    if (!propertiesFile.isFile()) {
        return;
    }

    Properties properties = new Properties();
    try {
        FileInputStream inputStream = new FileInputStream(propertiesFile);
        try {
            properties.load(inputStream);
        } finally {
            inputStream.close();
        }
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }

    for (Object key : properties.keySet()) {
        if (GradleProperties.ALL.contains(key.toString())) {
            result.put(key.toString(), properties.get(key).toString());
        }
    }
}
 

import org.gradle.api.UncheckedIOException; //导入依赖的package包/类
public static Scriptable parse(File source, String encoding, Action<Context> contextConfig) {
    Context context = Context.enter();
    if (contextConfig != null) {
        contextConfig.execute(context);
    }

    Scriptable scope = context.initStandardObjects();
    try {
        Reader reader = new InputStreamReader(new FileInputStream(source), encoding);
        try {
            context.evaluateReader(scope, reader, source.getName(), 0, null);
        } finally {
            reader.close();
        }
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    } finally {
        Context.exit();
    }

    return scope;
}
 

import org.gradle.api.UncheckedIOException; //导入依赖的package包/类
private JavaVersion parseJavaVersionCommandOutput(String javaExecutable, BufferedReader reader) {
    try {
        String versionStr = reader.readLine();
        while (versionStr != null) {
            Matcher matcher = Pattern.compile("(?:java|openjdk) version \"(.+?)\"").matcher(versionStr);
            if (matcher.matches()) {
                return JavaVersion.toVersion(matcher.group(1));
            }
            versionStr = reader.readLine();
        }
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }

    throw new GradleException(String.format("Could not determine Java version using executable %s.", javaExecutable));
}
 

import org.gradle.api.UncheckedIOException; //导入依赖的package包/类
/**
 * Saves the settings of the file chooser; and by settings I mean the 'last visited directory'.
 *
 * @param saveCurrentDirectoryVsSelectedFilesParent this should be true if you're selecting only directories, false if you're selecting only files. I don't know what if you allow both.
 */
public static void saveSettings(SettingsNode settingsNode, JFileChooser fileChooser, String id, Class fileChooserClass, boolean saveCurrentDirectoryVsSelectedFilesParent) {
    SettingsNode childNode = settingsNode.addChildIfNotPresent(getPrefix(fileChooserClass, id));

    String save;
    try {
        if (saveCurrentDirectoryVsSelectedFilesParent) {
            save = fileChooser.getCurrentDirectory().getCanonicalPath();
        } else {
            save = fileChooser.getSelectedFile().getCanonicalPath();
        }
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
    if (save != null) {
        childNode.setValueOfChild(DIRECTORY_NAME, save);
    }
}
 

import org.gradle.api.UncheckedIOException; //导入依赖的package包/类
/**
 * If you do have an init script that's a resource, this will extract it based on the name and write it to a temporary file and delete it on exit.
 *
 * @param resourceClass the class associated with the resource
 * @param resourceName the name (minus extension or '.') of the resource
 */
protected File extractInitScriptFile(Class resourceClass, String resourceName) {
    File file = null;
    try {
        file = temporaryFileProvider.createTemporaryFile(resourceName, INIT_SCRIPT_EXTENSION);
    } catch (UncheckedIOException e) {
        logger.error("Creating init script file temp file", e);
        return null;
    }
    file.deleteOnExit();

    if (extractResourceAsFile(resourceClass, resourceName + INIT_SCRIPT_EXTENSION, file)) {
        return file;
    }

    logger.error("Internal error! Failed to extract init script for executing commands!");

    return null;
}
 

import org.gradle.api.UncheckedIOException; //导入依赖的package包/类
private void processDirectory(File file, final Trie.Builder builder) {
    new DirectoryFileTree(file).visit(new FileVisitor() {
        @Override
        public void visitDir(FileVisitDetails dirDetails) {
        }

        @Override
        public void visitFile(FileVisitDetails fileDetails) {
            try {
                ZipEntry zipEntry = new ZipEntry(fileDetails.getPath());
                InputStream inputStream = fileDetails.open();
                try {
                    processEntry(zipEntry, builder);
                } finally {
                    inputStream.close();
                }
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        }
    });
}
 

import org.gradle.api.UncheckedIOException; //导入依赖的package包/类
@Override
public void write(IvyModulePublishMetadata module, File output) {
    try {
        output.getParentFile().mkdirs();
        OutputStream outputStream = new FileOutputStream(output);
        try {
            SimpleXmlWriter xmlWriter = new SimpleXmlWriter(outputStream, "  ");
            writeTo(module, xmlWriter);
            xmlWriter.flush();
        } finally {
            outputStream.close();
        }
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

import org.gradle.api.UncheckedIOException; //导入依赖的package包/类
public void publish(List<ModuleVersionPublisher> publishResolvers,
                    IvyModulePublishMetadata publishMetaData) {
    try {
        // Make a copy of the publication and filter missing artifacts
        DefaultIvyModulePublishMetadata publication = new DefaultIvyModulePublishMetadata(publishMetaData.getId(), publishMetaData.getModuleDescriptor());
        for (IvyModuleArtifactPublishMetadata artifact: publishMetaData.getArtifacts()) {
            addPublishedArtifact(artifact, publication);
        }
        for (ModuleVersionPublisher publisher : publishResolvers) {
            LOGGER.info("Publishing to {}", publisher);
            publisher.publish(publication);
        }
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

import org.gradle.api.UncheckedIOException; //导入依赖的package包/类
private File findExecutable(OperatingSystem operatingSystem, String name) {
    List<File> path = pathEntries.isEmpty() ? operatingSystem.getPath() : pathEntries;
    String exeName = operatingSystem.getExecutableName(name);
    try {
        if (name.contains(File.separator)) {
            return maybeResolveFile(operatingSystem, new File(name), new File(exeName));
        }
        for (File pathEntry : path) {
            File resolved = maybeResolveFile(operatingSystem, new File(pathEntry, name), new File(pathEntry, exeName));
            if (resolved != null) {
                return resolved;
            }
        }
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }

    return null;
}
 

import org.gradle.api.UncheckedIOException; //导入依赖的package包/类
public void generateReport(Set<Project> projects) {
    try {
        ReportRenderer renderer = getRenderer();
        renderer.setClientMetaData(getClientMetaData());
        File outputFile = getOutputFile();
        if (outputFile != null) {
            renderer.setOutputFile(outputFile);
        } else {
            renderer.setOutput(getTextOutputFactory().create(getClass()));
        }
        for (Project project : projects) {
            renderer.startProject(project);
            projectReportGenerator.generateReport(project);
            renderer.completeProject(project);
        }
        renderer.complete();
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}