/* sbt -- Simple Build Tool
 * Copyright 2008, 2009 Mark Harrah
 */
package sbt

import java.io.{Closeable, File, FileInputStream, FileOutputStream, InputStream, OutputStream}
import java.io.{ByteArrayOutputStream, InputStreamReader, OutputStreamWriter}
import java.io.{BufferedReader, BufferedWriter, FileReader, FileWriter, Reader, Writer}
import java.net.URL
import java.nio.charset.{Charset, CharsetDecoder, CharsetEncoder}
import java.nio.channels.FileChannel
import java.util.jar.{Attributes, JarEntry, JarFile, JarOutputStream, Manifest}
import java.util.zip.{GZIPOutputStream, ZipEntry, ZipInputStream, ZipOutputStream}

/** A collection of file related methods. */
object object sbt.FileUtilitiesFileUtilities
{
	/** The size of the byte or char buffer used in various methods.*/
	private val IntBufferSize = Int(8192)8192
	private val java.lang.StringNewline = object java.lang.SystemSystem.(java.lang.String)java.lang.StringgetProperty(java.lang.String("line.separator")"line.separator")
	/** A pattern used to split a String by path separator characters.*/
	private val java.util.regex.PatternPathSeparatorPattern = java.util.regex.object java.util.regex.PatternPattern.(java.lang.String)java.util.regex.Patterncompile(object java.io.FileFile.java.lang.StringpathSeparator)

	/** Splits a String around path separator characters. */
	private[sbt] def (String)Array[java.lang.String]pathSplit(Strings: StringString) = => java.util.regex.PatternPathSeparatorPattern.(java.lang.CharSequence)Array[java.lang.String]split(Strings)
	
	/** Gzips the file 'in' and writes it to 'out'.  'in' cannot be the same file as 'out'. */
	def (sbt.Path,sbt.Path,sbt.Logger)Option[String]gzip(sbt.Pathin: sbt.PathPath, sbt.Pathout: sbt.PathPath, sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
	{
		(Boolean,=> Any)Unitrequire(sbt.Pathin (AnyRef)Boolean!= sbt.Pathout, java.lang.String("Input file cannot be the same as the output file.")"Input file cannot be the same as the output file.")
		(java.io.File,sbt.Logger)((java.io.InputStream) => Option[String])Option[String]readStream(sbt.Pathin.=> java.io.FileasFile, sbt.Loggerlog) { java.io.InputStreaminputStream =>
			(java.io.File,sbt.Logger)((java.io.OutputStream) => Option[String])Option[String]writeStream(sbt.Pathout.=> java.io.FileasFile, sbt.Loggerlog) { java.io.OutputStreamoutputStream =>
				val java.util.zip.GZIPOutputStreamgzStream = (java.io.OutputStream)java.util.zip.GZIPOutputStreamnew java.util.zip.GZIPOutputStreamGZIPOutputStream(java.io.OutputStreamoutputStream)
				object sbt.ControlControl.(=> String,sbt.Logger)(=> Option[String])(=> Unit)Option[String]trapUnitAndFinally(java.lang.String("Error gzipping '")"Error gzipping '" (Any)java.lang.String+ sbt.Pathin (Any)java.lang.String+ java.lang.String("' to '")"' to '" (Any)java.lang.String+ sbt.Pathout (Any)java.lang.String+ java.lang.String("': ")"': ", sbt.Loggerlog)
					{ (java.io.InputStream,java.io.OutputStream,sbt.Logger)Option[String]transfer(java.io.InputStreaminputStream, java.util.zip.GZIPOutputStreamgzStream, sbt.Loggerlog) }
					{ java.util.zip.GZIPOutputStreamgzStream.()Unitclose() }
			}
		}
	}
	/** Gzips the InputStream 'in' and writes it to 'output'.  Neither stream is closed.*/
	def (java.io.InputStream,java.io.OutputStream,sbt.Logger)Option[String]gzip(java.io.InputStreaminput: java.io.InputStreamInputStream, java.io.OutputStreamoutput: java.io.OutputStreamOutputStream, sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
	{
		val java.util.zip.GZIPOutputStreamgzStream = (java.io.OutputStream)java.util.zip.GZIPOutputStreamnew java.util.zip.GZIPOutputStreamGZIPOutputStream(java.io.OutputStreamoutput)
		object sbt.ControlControl.(=> String,sbt.Logger)(=> Option[String])(=> Unit)Option[String]trapUnitAndFinally(java.lang.String("Error gzipping: ")"Error gzipping: ", sbt.Loggerlog)
			{ (java.io.InputStream,java.io.OutputStream,sbt.Logger)Option[String]transfer(java.io.InputStreaminput, java.util.zip.GZIPOutputStreamgzStream, sbt.Loggerlog) }
			{ java.util.zip.GZIPOutputStreamgzStream.()Unitfinish() }
	}
	
	/** Creates a jar file.
	* @param sources The files to include in the jar file.  The path used for the jar is
	* relative to the base directory for the source.  That is, the path in the jar for source
	* <code>(basePath ##) / x / y</code> is <code>x / y</code>.
	* @param outputJar The file to write the jar to.
	* @param manifest The manifest for the jar.
	* @param recursive If true, any directories in <code>sources</code> are recursively processed.  Otherwise,
	* they are not
	* @param log The Logger to use. */
	def (Iterable[sbt.Path],sbt.Path,java.util.jar.Manifest,Boolean,sbt.Logger)Option[String]jar(Iterable[sbt.Path]sources: Iterable[sbt.Path]Iterable[Path], sbt.PathoutputJar: sbt.PathPath, java.util.jar.Manifestmanifest: java.util.jar.ManifestManifest, Booleanrecursive: BooleanBoolean, sbt.Loggerlog: sbt.LoggerLogger) =
		(Iterable[sbt.Path],sbt.Path,Option[java.util.jar.Manifest],Boolean,sbt.Logger)Option[String]archive(Iterable[sbt.Path]sources, sbt.PathoutputJar, (java.util.jar.Manifest)Some[java.util.jar.Manifest]Some(java.util.jar.Manifestmanifest), Booleanrecursive, sbt.Loggerlog)
	@deprecateddeprecated def (Iterable[sbt.Path],sbt.Path,java.util.jar.Manifest,Boolean,sbt.Logger)Option[String]pack(Iterable[sbt.Path]sources: Iterable[sbt.Path]Iterable[Path], sbt.PathoutputJar: sbt.PathPath, java.util.jar.Manifestmanifest: java.util.jar.ManifestManifest, Booleanrecursive: BooleanBoolean, sbt.Loggerlog: sbt.LoggerLogger) =
		(Iterable[sbt.Path],sbt.Path,java.util.jar.Manifest,Boolean,sbt.Logger)Option[String]jar(Iterable[sbt.Path]sources, sbt.PathoutputJar, java.util.jar.Manifestmanifest, Booleanrecursive, sbt.Loggerlog)
	/** Creates a zip file.
	* @param sources The files to include in the jar file.  The path used for the jar is
	* relative to the base directory for the source.  That is, the path in the jar for source
	* <code>(basePath ##) / x / y</code> is <code>x / y</code>.
	* @param outputZip The file to write the zip to.
	* @param recursive If true, any directories in <code>sources</code> are recursively processed.  Otherwise,
	* they are not
	* @param log The Logger to use. */
	def (Iterable[sbt.Path],sbt.Path,Boolean,sbt.Logger)Option[String]zip(Iterable[sbt.Path]sources: Iterable[sbt.Path]Iterable[Path], sbt.PathoutputZip: sbt.PathPath, Booleanrecursive: BooleanBoolean, sbt.Loggerlog: sbt.LoggerLogger) =
		(Iterable[sbt.Path],sbt.Path,Option[java.util.jar.Manifest],Boolean,sbt.Logger)Option[String]archive(Iterable[sbt.Path]sources, sbt.PathoutputZip, object NoneNone, Booleanrecursive, sbt.Loggerlog)
	
	private def (Iterable[sbt.Path],sbt.Path,Option[java.util.jar.Manifest],Boolean,sbt.Logger)Option[String]archive(Iterable[sbt.Path]sources: Iterable[sbt.Path]Iterable[Path], sbt.PathoutputPath: sbt.PathPath, Option[java.util.jar.Manifest]manifest: Option[java.util.jar.Manifest]Option[Manifest], Booleanrecursive: BooleanBoolean, sbt.Loggerlog: sbt.LoggerLogger) =
	{
		sbt.Loggerlog.(=> String)Unitinfo(java.lang.String("Packaging ")"Packaging " (Any)java.lang.String+ sbt.PathoutputPath (Any)java.lang.String+ java.lang.String(" ...")" ...")
		val java.io.FileoutputFile = sbt.PathoutputPath.=> java.io.FileasFile
		Option[String]if(java.io.FileoutputFile.()BooleanisDirectory)
			(java.lang.String)Some[java.lang.String]Some(java.lang.String("Specified output file ")"Specified output file " (Any)java.lang.String+ java.io.FileoutputFile (Any)java.lang.String+ java.lang.String(" is a directory.")" is a directory.")
		else
		{
			val java.io.FileoutputDir = java.io.FileoutputFile.()java.io.FilegetParentFile
			val Option[String]result = (java.io.File,sbt.Logger)Option[String]createDirectory(java.io.FileoutputDir, sbt.Loggerlog) (=> Option[String])Option[String]orElse
				(java.io.File,Option[java.util.jar.Manifest],sbt.Logger)((java.util.zip.ZipOutputStream) => Option[String])Option[String]withZipOutput(java.io.FileoutputFile, Option[java.util.jar.Manifest]manifest, sbt.Loggerlog)
				{ java.util.zip.ZipOutputStreamoutput =>
					val (String) => java.util.zip.ZipEntrycreateEntry: (String => ZipEntry) = (String) => java.util.zip.ZipEntryif(Option[java.util.jar.Manifest]manifest.=> BooleanisDefined) java.util.jar.JarEntrynew java.util.jar.JarEntryJarEntry(String_) else java.util.zip.ZipEntrynew java.util.zip.ZipEntryZipEntry(String_)
					(Iterable[sbt.Path],java.util.zip.ZipOutputStream,Boolean,sbt.Logger)((String) => java.util.zip.ZipEntry)object NonewriteZip(Iterable[sbt.Path]sources, java.util.zip.ZipOutputStreamoutput, Booleanrecursive, sbt.Loggerlog)((String) => java.util.zip.ZipEntrycreateEntry)
				}
			Unitif(Option[String]result.=> BooleanisEmpty)
				sbt.Loggerlog.(=> String)Unitinfo(java.lang.String("Packaging complete.")"Packaging complete.")
			Option[String]result
		}
	}
	
	private def (Iterable[sbt.Path],java.util.zip.ZipOutputStream,Boolean,sbt.Logger)((String) => java.util.zip.ZipEntry)object NonewriteZip(Iterable[sbt.Path]sources: Iterable[sbt.Path]Iterable[Path], java.util.zip.ZipOutputStreamoutput: java.util.zip.ZipOutputStreamZipOutputStream, Booleanrecursive: BooleanBoolean, sbt.Loggerlog: sbt.LoggerLogger)((String) => java.util.zip.ZipEntrycreateEntry: String => ZipEntry) =
	{
		def (sbt.Path)Unitadd(sbt.Pathsource: sbt.PathPath)
		{
			val java.io.FilesourceFile = sbt.Pathsource.=> java.io.FileasFile
			Unitif(java.io.FilesourceFile.()BooleanisDirectory)
			{
				Unitif(Booleanrecursive)
					(Array[java.io.File])Array[java.io.File]wrapNull(java.io.FilesourceFile.()Array[java.io.File]listFiles).((java.io.File) => Unit)Unitforeach(java.io.Filefile => (sbt.Path)Unitadd(sbt.Pathsource (String)sbt.Path/ java.io.Filefile.()java.lang.StringgetName))
			}
			else Unitif(java.io.FilesourceFile.()Booleanexists)
			{
				sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("\011Adding ")"\tAdding " (Any)java.lang.String+ sbt.Pathsource (Any)java.lang.String+ java.lang.String(" ...")" ...")
				val java.util.zip.ZipEntrynextEntry = (String)java.util.zip.ZipEntrycreateEntry(sbt.Pathsource.=> StringrelativePath)
				java.util.zip.ZipEntrynextEntry.(Long)UnitsetTime(java.io.FilesourceFile.()LonglastModified)
				java.util.zip.ZipOutputStreamoutput.(java.util.zip.ZipEntry)UnitputNextEntry(java.util.zip.ZipEntrynextEntry)
				(java.io.InputStream,java.io.OutputStream,sbt.Logger)Option[String]transferAndClose((java.io.File)java.io.FileInputStreamnew java.io.FileInputStreamFileInputStream(java.io.FilesourceFile), java.util.zip.ZipOutputStreamoutput, sbt.Loggerlog)
			}
			else
				sbt.Loggerlog.(=> String)Unitwarn(java.lang.String("\011Source ")"\tSource " (Any)java.lang.String+ sbt.Pathsource (Any)java.lang.String+ java.lang.String(" does not exist.")" does not exist.")
		}
		Iterable[sbt.Path]sources.((sbt.Path) => Unit)Unitforeach((sbt.Path)Unitadd)
		java.util.zip.ZipOutputStreamoutput.()UnitcloseEntry()
		object NoneNone
	}
	
	private def (java.io.File,Option[java.util.jar.Manifest],sbt.Logger)((java.util.zip.ZipOutputStream) => Option[String])Option[String]withZipOutput(java.io.Filefile: java.io.FileFile, Option[java.util.jar.Manifest]manifest: Option[java.util.jar.Manifest]Option[Manifest], sbt.Loggerlog: sbt.LoggerLogger)((java.util.zip.ZipOutputStream) => Option[String]f: ZipOutputStream => Option[String]): Option[String]Option[String] =
	{
		(java.io.File,sbt.Logger)((java.io.OutputStream) => Option[String])Option[String]writeStream(java.io.Filefile: java.io.FileFile, sbt.Loggerlog: sbt.LoggerLogger)
		{
			java.io.OutputStreamfileOut =>
			{
				val (java.util.zip.ZipOutputStream, java.lang.String)(java.util.zip.ZipOutputStreamzipOut, java.lang.Stringext) =
					Option[java.util.jar.Manifest]manifest (java.util.zip.ZipOutputStream, java.lang.String)match
					{
						(java.util.jar.JarOutputStream, java.lang.String)case Some(java.util.jar.Manifestmf) =>
						{
							import Attributes.Name.MANIFEST_VERSION
							val java.util.jar.Attributesmain = java.util.jar.Manifestmf.()java.util.jar.AttributesgetMainAttributes
							Anyif(=> Boolean!java.util.jar.Attributesmain.(Any)BooleancontainsKey(java.util.jar.Attributes.NameMANIFEST_VERSION))
								java.util.jar.Attributesmain.(Any,Any)java.lang.Objectput(java.util.jar.Attributes.NameMANIFEST_VERSION, java.lang.String("1.0")"1.0")
							(java.util.jar.JarOutputStream,java.lang.String)(java.util.jar.JarOutputStream, java.lang.String)(java.util.jar.JarOutputStreamnew java.util.jar.JarOutputStreamJarOutputStream(java.io.OutputStreamfileOut, java.util.jar.Manifestmf), java.lang.String("jar")"jar")
						}
						(java.util.zip.ZipOutputStream, java.lang.String)case object NoneNone => (java.util.zip.ZipOutputStream,java.lang.String)(java.util.zip.ZipOutputStream, java.lang.String)(java.util.zip.ZipOutputStreamnew java.util.zip.ZipOutputStreamZipOutputStream(java.io.OutputStreamfileOut), java.lang.String("zip")"zip")
					}
				object sbt.ControlControl.(=> String,sbt.Logger)(=> Option[String])(=> Unit)Option[String]trapUnitAndFinally(java.lang.String("Error writing ")"Error writing " (Any)java.lang.String+ java.lang.Stringext (Any)java.lang.String+ java.lang.String(": ")": ", sbt.Loggerlog)
					{ (java.util.zip.ZipOutputStream)Option[String]f(java.util.zip.ZipOutputStreamzipOut) } { java.util.zip.ZipOutputStreamzipOut.()Unitclose }
			}
		}
	}
	import scala.collection.Set
	/** Unzips the contents of the zip file <code>from</code> to the <code>toDirectory</code> directory.*/
	def (sbt.Path,sbt.Path,sbt.Logger)Either[String,scala.collection.Set[sbt.Path]]unzip(sbt.Pathfrom: sbt.PathPath, sbt.PathtoDirectory: sbt.PathPath, sbt.Loggerlog: sbt.LoggerLogger): Either[String,scala.collection.Set[sbt.Path]]Either[String, Set[Path]] =
		(sbt.Path,sbt.Path,sbt.NameFilter,sbt.Logger)Either[String,scala.collection.Set[sbt.Path]]unzip(sbt.Pathfrom, sbt.PathtoDirectory, object sbt.AllPassFilterAllPassFilter, sbt.Loggerlog)
	/** Unzips the contents of the zip file <code>from</code> to the <code>toDirectory</code> directory.*/
	def (java.io.File,sbt.Path,sbt.Logger)Either[String,scala.collection.Set[sbt.Path]]unzip(java.io.Filefrom: java.io.FileFile, sbt.PathtoDirectory: sbt.PathPath, sbt.Loggerlog: sbt.LoggerLogger): Either[String,scala.collection.Set[sbt.Path]]Either[String, Set[Path]] =
		(java.io.File,sbt.Path,sbt.NameFilter,sbt.Logger)Either[String,scala.collection.Set[sbt.Path]]unzip(java.io.Filefrom, sbt.PathtoDirectory, object sbt.AllPassFilterAllPassFilter, sbt.Loggerlog)
	/** Unzips the contents of the zip file <code>from</code> to the <code>toDirectory</code> directory.*/
	def (java.io.InputStream,sbt.Path,sbt.Logger)Either[String,scala.collection.Set[sbt.Path]]unzip(java.io.InputStreamfrom: java.io.InputStreamInputStream, sbt.PathtoDirectory: sbt.PathPath, sbt.Loggerlog: sbt.LoggerLogger): Either[String,scala.collection.Set[sbt.Path]]Either[String, Set[Path]] =
		(java.io.InputStream,sbt.Path,sbt.NameFilter,sbt.Logger)Either[String,scala.collection.Set[sbt.Path]]unzip(java.io.InputStreamfrom, sbt.PathtoDirectory, object sbt.AllPassFilterAllPassFilter, sbt.Loggerlog)
	/** Unzips the contents of the zip file <code>from</code> to the <code>toDirectory</code> directory.*/
	def (java.net.URL,sbt.Path,sbt.Logger)Either[String,scala.collection.Set[sbt.Path]]unzip(java.net.URLfrom: java.net.URLURL, sbt.PathtoDirectory: sbt.PathPath, sbt.Loggerlog: sbt.LoggerLogger): Either[String,scala.collection.Set[sbt.Path]]Either[String, Set[Path]] =
		(java.net.URL,sbt.Path,sbt.NameFilter,sbt.Logger)Either[String,scala.collection.Set[sbt.Path]]unzip(java.net.URLfrom, sbt.PathtoDirectory, object sbt.AllPassFilterAllPassFilter, sbt.Loggerlog)
	
	/** Unzips the contents of the zip file <code>from</code> to the <code>toDirectory</code> directory.
	* Only the entries that match the given filter are extracted. */
	def (sbt.Path,sbt.Path,sbt.NameFilter,sbt.Logger)Either[String,scala.collection.Set[sbt.Path]]unzip(sbt.Pathfrom: sbt.PathPath, sbt.PathtoDirectory: sbt.PathPath, sbt.NameFilterfilter: sbt.NameFilterNameFilter, sbt.Loggerlog: sbt.LoggerLogger): Either[String,scala.collection.Set[sbt.Path]]Either[String, Set[Path]] =
		(java.io.File,sbt.Path,sbt.NameFilter,sbt.Logger)Either[String,scala.collection.Set[sbt.Path]]unzip(sbt.Pathfrom.=> java.io.FileasFile, sbt.PathtoDirectory, sbt.NameFilterfilter, sbt.Loggerlog)
	/** Unzips the contents of the zip file <code>from</code> to the <code>toDirectory</code> directory.
	* Only the entries that match the given filter are extracted. */
	def (java.io.File,sbt.Path,sbt.NameFilter,sbt.Logger)Either[String,scala.collection.Set[sbt.Path]]unzip(java.io.Filefrom: java.io.FileFile, sbt.PathtoDirectory: sbt.PathPath, sbt.NameFilterfilter: sbt.NameFilterNameFilter, sbt.Loggerlog: sbt.LoggerLogger): Either[String,scala.collection.Set[sbt.Path]]Either[String, Set[Path]] =
		(java.io.File,sbt.Logger)((java.io.InputStream) => Either[String,scala.collection.Set[sbt.Path]])Either[String,scala.collection.Set[sbt.Path]]readStreamValue(java.io.Filefrom, sbt.Loggerlog)(java.io.InputStreamin => (java.io.InputStream,sbt.Path,sbt.NameFilter,sbt.Logger)Either[String,scala.collection.Set[sbt.Path]]unzip(java.io.InputStreamin, sbt.PathtoDirectory, sbt.NameFilterfilter, sbt.Loggerlog))
	/** Unzips the contents of the zip file <code>from</code> to the <code>toDirectory</code> directory.
	* Only the entries that match the given filter are extracted. */
	def (java.net.URL,sbt.Path,sbt.NameFilter,sbt.Logger)Either[String,scala.collection.Set[sbt.Path]]unzip(java.net.URLfrom: java.net.URLURL, sbt.PathtoDirectory: sbt.PathPath, sbt.NameFilterfilter: sbt.NameFilterNameFilter, sbt.Loggerlog: sbt.LoggerLogger): Either[String,scala.collection.Set[sbt.Path]]Either[String, Set[Path]] =
		(java.net.URL,sbt.Logger)((java.io.InputStream) => Either[String,scala.collection.Set[sbt.Path]])Either[String,scala.collection.Set[sbt.Path]]readStreamValue(java.net.URLfrom, sbt.Loggerlog) { java.io.InputStreamstream => (java.io.InputStream,sbt.Path,sbt.NameFilter,sbt.Logger)Either[String,scala.collection.Set[sbt.Path]]unzip(java.io.InputStreamstream, sbt.PathtoDirectory, sbt.NameFilterfilter, sbt.Loggerlog) }
	/** Unzips the contents of the zip file <code>from</code> to the <code>toDirectory</code> directory.
	* Only the entries that match the given filter are extracted. */
	def (java.io.InputStream,sbt.Path,sbt.NameFilter,sbt.Logger)Either[String,scala.collection.Set[sbt.Path]]unzip(java.io.InputStreamfrom: java.io.InputStreamInputStream, sbt.PathtoDirectory: sbt.PathPath, sbt.NameFilterfilter: sbt.NameFilterNameFilter, sbt.Loggerlog: sbt.LoggerLogger): Either[String,scala.collection.Set[sbt.Path]]Either[String, Set[Path]] =
	{
		(sbt.Path,sbt.Logger)Option[String]createDirectory(sbt.PathtoDirectory, sbt.Loggerlog) Either[String,scala.collection.Set[sbt.Path]]match
		{
			Left[String,Nothing]case Some(Stringerr) => (String)Left[String,Nothing]Left(Stringerr)
			Either[String,scala.collection.Set[sbt.Path]]case object NoneNone =>
			{
				val java.util.zip.ZipInputStreamzipInput = java.util.zip.ZipInputStreamnew java.util.zip.ZipInputStreamZipInputStream(java.io.InputStreamfrom)
				object sbt.ControlControl.(=> String,sbt.Logger)(=> Either[String,scala.collection.Set[sbt.Path]])(=> Unit)Either[String,scala.collection.Set[sbt.Path]]trapAndFinally(java.lang.String("Error unzipping: ")"Error unzipping: ", sbt.Loggerlog)
				{ (java.util.zip.ZipInputStream,sbt.Path,sbt.NameFilter,sbt.Logger)Either[String,scala.collection.Set[sbt.Path]] with Productextract(java.util.zip.ZipInputStreamzipInput, sbt.PathtoDirectory, sbt.NameFilterfilter, sbt.Loggerlog) }
				{ java.util.zip.ZipInputStreamzipInput.()Unitclose() }
			}
		}
	}
	private def (java.util.zip.ZipInputStream,sbt.Path,sbt.NameFilter,sbt.Logger)Either[String,scala.collection.Set[sbt.Path]] with Productextract(java.util.zip.ZipInputStreamfrom: java.util.zip.ZipInputStreamZipInputStream, sbt.PathtoDirectory: sbt.PathPath, sbt.NameFilterfilter: sbt.NameFilterNameFilter, sbt.Loggerlog: sbt.LoggerLogger) =
	{
		val scala.collection.mutable.HashSet[sbt.Path]set = scala.collection.mutable.HashSet[sbt.Path]new scala.collection.mutable.scala.collection.mutable.HashSet[sbt.Path]HashSet[Path]
		def ()Option[String]next(): Option[String]Option[String] =
		{
			val java.util.zip.ZipEntryentry = java.util.zip.ZipInputStreamfrom.()java.util.zip.ZipEntrygetNextEntry
			Option[String]if(java.util.zip.ZipEntryentry (AnyRef)Boolean== Null(null)null)
				object NoneNone
			else
			{
				val java.lang.Stringname = java.util.zip.ZipEntryentry.()java.lang.StringgetName
				val Option[String]result =
					Option[String]if(sbt.NameFilterfilter.(String)Booleanaccept(java.lang.Stringname))
					{
						val sbt.Pathtarget = object sbt.PathPath.(sbt.Path,String)sbt.PathfromString(sbt.PathtoDirectory, java.lang.Stringname)
						sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Extracting zip entry '")"Extracting zip entry '" (Any)java.lang.String+ java.lang.Stringname (Any)java.lang.String+ java.lang.String("' to '")"' to '" (Any)java.lang.String+ sbt.Pathtarget (Any)java.lang.String+ java.lang.String("'")"'")
						val Option[String]result =
							Option[String]if(java.util.zip.ZipEntryentry.()BooleanisDirectory)
								(sbt.Path,sbt.Logger)Option[String]createDirectory(sbt.Pathtarget, sbt.Loggerlog)
							else
								(java.io.File,sbt.Logger)((java.io.OutputStream) => Option[String])Option[String]writeStream(sbt.Pathtarget.=> java.io.FileasFile, sbt.Loggerlog) { java.io.OutputStreamout => object sbt.FileUtilitiesFileUtilities.(java.io.InputStream,java.io.OutputStream,sbt.Logger)Option[String]transfer(java.util.zip.ZipInputStreamfrom, java.io.OutputStreamout, sbt.Loggerlog) }
						//target.asFile.setLastModified(entry.getTime)
						Option[String]result
					}
					else
					{
						sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Ignoring zip entry '")"Ignoring zip entry '" (Any)java.lang.String+ java.lang.Stringname (Any)java.lang.String+ java.lang.String("'")"'")
						object NoneNone
					}
				java.util.zip.ZipInputStreamfrom.()UnitcloseEntry()
				Option[String]result Option[String]match { Option[String]case object NoneNone => ()Option[String]next(); Option[String]case Option[String]x => Option[String]x }
			}
		}
		()Option[String]next().(=> scala.collection.Set[sbt.Path])Either[String,scala.collection.Set[sbt.Path]] with ProducttoLeft(scala.collection.mutable.HashSet[sbt.Path]set.=> scala.collection.Set[sbt.Path]readOnly)
	}
	
	/** Copies all bytes from the given input stream to the given output stream.
	* Neither stream is closed.*/
	def (java.io.InputStream,java.io.OutputStream,sbt.Logger)Option[String]transfer(java.io.InputStreamin: java.io.InputStreamInputStream, java.io.OutputStreamout: java.io.OutputStreamOutputStream, sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
		(java.io.InputStream,java.io.OutputStream,Boolean,sbt.Logger)Option[String]transferImpl(java.io.InputStreamin, java.io.OutputStreamout, Boolean(false)false, sbt.Loggerlog)
	/** Copies all bytes from the given input stream to the given output stream.  The
	* input stream is closed after the method completes.*/
	def (java.io.InputStream,java.io.OutputStream,sbt.Logger)Option[String]transferAndClose(java.io.InputStreamin: java.io.InputStreamInputStream, java.io.OutputStreamout: java.io.OutputStreamOutputStream, sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
		(java.io.InputStream,java.io.OutputStream,Boolean,sbt.Logger)Option[String]transferImpl(java.io.InputStreamin, java.io.OutputStreamout, Boolean(true)true, sbt.Loggerlog)
	private def (java.io.InputStream,java.io.OutputStream,Boolean,sbt.Logger)Option[String]transferImpl(java.io.InputStreamin: java.io.InputStreamInputStream, java.io.OutputStreamout: java.io.OutputStreamOutputStream, Booleanclose: BooleanBoolean, sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
	{
		object sbt.ControlControl.(=> String,sbt.Logger)(=> Option[String])(=> Unit)Option[String]trapUnitAndFinally(java.lang.String("Error during transfer: ")"Error during transfer: ", sbt.Loggerlog)
		{
			val Array[Byte]buffer = Array[Byte]new Array[Byte]Array[Byte](=> IntBufferSize)
			def => None.typeread: None.type =
			{
				val IntbyteCount = java.io.InputStreamin.(Array[Byte])Intread(Array[Byte]buffer)
				None.typeif(IntbyteCount (Int)Boolean>= Int(0)0)
				{
					java.io.OutputStreamout.(Array[Byte],Int,Int)Unitwrite(Array[Byte]buffer, Int(0)0, IntbyteCount)
					=> None.typeread
				}
				else
					object NoneNone
			}
			=> None.typeread
		}
		{ Unitif(Booleanclose) java.io.InputStreamin.()Unitclose }
	}

	/** Creates a file at the given location.*/
	def (sbt.Path,sbt.Logger)Option[String]touch(sbt.Pathpath: sbt.PathPath, sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] = (java.io.File,sbt.Logger)Option[String]touch(sbt.Pathpath.=> java.io.FileasFile, sbt.Loggerlog)
	/** Creates a file at the given location.*/
	def (java.io.File,sbt.Logger)Option[String]touch(java.io.Filefile: java.io.FileFile, sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
	{
		object sbt.ControlControl.(=> String,sbt.Logger)(=> Option[String])Option[String]trapUnit(java.lang.String("Could not create file ")"Could not create file " (Any)java.lang.String+ java.io.Filefile (Any)java.lang.String+ java.lang.String(": ")": ", sbt.Loggerlog)
		{
			Option[String]if(java.io.Filefile.()Booleanexists)
			{
				def => java.lang.StringupdateFailBase = java.lang.String("Could not update last modified for file ")"Could not update last modified for file " (Any)java.lang.String+ java.io.Filefile
				object sbt.ControlControl.(=> String,sbt.Logger)(=> Option[String])Option[String]trapUnit(=> java.lang.StringupdateFailBase (Any)java.lang.String+ java.lang.String(": ")": ", sbt.Loggerlog)
					{ Option[String]if(java.io.Filefile.(Long)BooleansetLastModified(object java.lang.SystemSystem.()LongcurrentTimeMillis)) object NoneNone else (java.lang.String)Some[java.lang.String]Some(=> java.lang.StringupdateFailBase) }
			}
			else
				(java.io.File,sbt.Logger)Option[String]createDirectory(java.io.Filefile.()java.io.FilegetParentFile, sbt.Loggerlog) (=> Option[String])Option[String]orElse { java.io.Filefile.()BooleancreateNewFile(); object NoneNone }
		}
	}
	/** Creates a directory at the given location.*/
	def (sbt.Path,sbt.Logger)Option[String]createDirectory(sbt.Pathdir: sbt.PathPath, sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] = (java.io.File,sbt.Logger)Option[String]createDirectory(sbt.Pathdir.=> java.io.FileasFile, sbt.Loggerlog)
	/** Creates a directory at the given location.*/
	def (java.io.File,sbt.Logger)Option[String]createDirectory(java.io.Filedir: java.io.FileFile, sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
	{
		object sbt.ControlControl.(=> String,sbt.Logger)(=> Option[String])Option[String]trapUnit(java.lang.String("Could not create directory ")"Could not create directory " (Any)java.lang.String+ java.io.Filedir (Any)java.lang.String+ java.lang.String(": ")": ", sbt.Loggerlog)
		{
			Option[String]if(java.io.Filedir.()Booleanexists)
			{
				Option[String]if(java.io.Filedir.()BooleanisDirectory)
					object NoneNone
				else
					(java.lang.String)Some[java.lang.String]Some(implicit scala.Predef.any2stringadd : (Any)scala.runtime.StringAdddir (String)java.lang.String+ java.lang.String(" exists and is not a directory.")" exists and is not a directory.")
			}
			else
			{
				java.io.Filedir.()Booleanmkdirs()
				sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Created directory ")"Created directory " (Any)java.lang.String+ java.io.Filedir)
				object NoneNone
			}
		}
	}
	/** Creates directories at the given locations.*/
	def (Seq[sbt.Path],sbt.Logger)Option[String]createDirectories(Seq[sbt.Path]d: Seq[sbt.Path]Seq[Path], sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] = (List[java.io.File],sbt.Logger)Option[String]createDirectories(Seq[sbt.Path]d.=> List[sbt.Path]toList.((sbt.Path) => java.io.File)List[java.io.File]map(sbt.Path_.=> java.io.FileasFile), sbt.Loggerlog)
	/** Creates directories at the given locations.*/
	def (List[java.io.File],sbt.Logger)Option[String]createDirectories(List[java.io.File]d: List[java.io.File]List[File], sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
		List[java.io.File]d Option[String]match
		{
			None.typecase object NilNil => object NoneNone
			Option[String]case java.io.Filehead :: List[java.io.File]tail => (java.io.File,sbt.Logger)Option[String]createDirectory(java.io.Filehead, sbt.Loggerlog) (=> Option[String])Option[String]orElse (List[java.io.File],sbt.Logger)Option[String]createDirectories(List[java.io.File]tail, sbt.Loggerlog)
		}
	/** The maximum number of times a unique temporary filename is attempted to be created.*/
	private val IntMaximumTries = Int(10)10
	/** Creates a temporary directory and returns it.*/
	def (sbt.Logger)Either[String,java.io.File]createTemporaryDirectory(sbt.Loggerlog: sbt.LoggerLogger): Either[String,java.io.File]Either[String, File] =
	{
		def (Int)Either[String,java.io.File]create(Inttries: IntInt): Either[String,java.io.File]Either[String, File] =
		{
			Either[String,java.io.File]if(Inttries (Int)Boolean> => IntMaximumTries)
				(java.lang.String)Left[java.lang.String,Nothing]Left(java.lang.String("Could not create temporary directory.")"Could not create temporary directory.")
			else
			{
				val java.lang.StringrandomName = java.lang.String("sbt_")"sbt_" (Any)java.lang.String+ java.lang.object java.lang.IntegerInteger.(Int)java.lang.StringtoHexString(=> java.util.Randomrandom.()IntnextInt)
				val java.io.Filef = (java.io.File,java.lang.String)java.io.Filenew java.io.FileFile(=> java.io.FiletemporaryDirectory, java.lang.StringrandomName)
				
				Either[String,java.io.File]if((java.io.File,sbt.Logger)Option[String]createDirectory(java.io.Filef, sbt.Loggerlog).=> BooleanisEmpty)
					(java.io.File)Right[Nothing,java.io.File]Right(java.io.Filef)
				else
					(Int)Either[String,java.io.File]create(Inttries (Int)Int+ Int(1)1)
			}
		}
		(Int)Either[String,java.io.File]create(Int(0)0)
	}

	/** Creates a temporary directory and provides its location to the given function.  The directory
	* is deleted after the function returns.*/
	def [T](sbt.Logger)((java.io.File) => Either[String,T])Either[String,T]doInTemporaryDirectory[>: Nothing <: AnyT](sbt.Loggerlog: sbt.LoggerLogger)((java.io.File) => Either[String,T]action: File => Either[String, T]): Either[String,T]Either[String, T] =
	{
		def (java.io.File)Either[String,T]doInDirectory(java.io.Filedir: java.io.FileFile): Either[String,T]Either[String, T] =
		{
			object sbt.ControlControl.(=> String,sbt.Logger)(=> Either[String,T])(=> Unit)Either[String,T]trapAndFinally(java.lang.String("")"", sbt.Loggerlog)
				{ (java.io.File)Either[String,T]action(java.io.Filedir) }
				{ (java.io.File,Boolean,sbt.Logger)Option[String]delete(java.io.Filedir, Boolean(true)true, sbt.Loggerlog) }
		}
		(sbt.Logger)Either[String,java.io.File]createTemporaryDirectory(sbt.Loggerlog).=> Either.RightProjection[String,java.io.File]right.((java.io.File) => Either[String,T])Either[String,T]flatMap((java.io.File)Either[String,T]doInDirectory)
	}
	
	/** Copies the files declared in <code>sources</code> to the <code>destinationDirectory</code>
	* directory.  The source directory hierarchy is flattened so that all copies are immediate
	* children of <code>destinationDirectory</code>.  Directories are not recursively entered.*/
	def (Iterable[sbt.Path],sbt.Path,sbt.Logger)Either[String,scala.collection.Set[sbt.Path]] with ProductcopyFlat(Iterable[sbt.Path]sources: Iterable[sbt.Path]Iterable[Path], sbt.PathdestinationDirectory: sbt.PathPath, sbt.Loggerlog: sbt.LoggerLogger) =
	{
		val scala.collection.mutable.HashSet[sbt.Path]targetSet = scala.collection.mutable.HashSet[sbt.Path]new scala.collection.mutable.scala.collection.mutable.HashSet[sbt.Path]HashSet[Path]
		(Iterable[sbt.Path],sbt.Path,sbt.Logger)((sbt.Path) => Option[String])Option[String]copyImpl(Iterable[sbt.Path]sources, sbt.PathdestinationDirectory, sbt.Loggerlog)
		{
			sbt.Pathsource =>
			{
				val java.io.Filefrom = sbt.Pathsource.=> java.io.FileasFile
				val sbt.PathtoPath = sbt.PathdestinationDirectory (String)sbt.Path/ java.io.Filefrom.()java.lang.StringgetName
				scala.collection.mutable.HashSet[sbt.Path]targetSet (sbt.Path)Unit+= sbt.PathtoPath
				val java.io.Fileto = sbt.PathtoPath.=> java.io.FileasFile
				Option[String]if(=> Boolean!java.io.Fileto.()Booleanexists (Boolean)Boolean|| java.io.Filefrom.()LonglastModified (Long)Boolean> java.io.Fileto.()LonglastModified (Boolean)Boolean&& => Boolean!java.io.Filefrom.()BooleanisDirectory)
				{
					sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Copying ")"Copying " (Any)java.lang.String+ sbt.Pathsource (Any)java.lang.String+ java.lang.String(" to ")" to " (Any)java.lang.String+ sbt.PathtoPath)
					(java.io.File,java.io.File,sbt.Logger)Option[String]copyFile(java.io.Filefrom, java.io.Fileto, sbt.Loggerlog)
				}
				else
					object NoneNone
			}
		}.(=> scala.collection.Set[sbt.Path])Either[String,scala.collection.Set[sbt.Path]] with ProducttoLeft(scala.collection.mutable.HashSet[sbt.Path]targetSet.=> scala.collection.Set[sbt.Path]readOnly)
	}
	private def (Iterable[sbt.Path],sbt.Path,sbt.Logger)((sbt.Path) => Option[String])Option[String]copyImpl(Iterable[sbt.Path]sources: Iterable[sbt.Path]Iterable[Path], sbt.PathdestinationDirectory: sbt.PathPath, sbt.Loggerlog: sbt.LoggerLogger)
		((sbt.Path) => Option[String]doCopy: Path => Option[String]): Option[String]Option[String] =
	{
		val java.io.Filetarget = sbt.PathdestinationDirectory.=> java.io.FileasFile
		val Option[String]creationError =
			Option[String]if(java.io.Filetarget.()BooleanisDirectory)
				object NoneNone
			else
				(java.io.File,sbt.Logger)Option[String]createDirectory(java.io.Filetarget, sbt.Loggerlog)
		def (List[sbt.Path])Option[String]copy(List[sbt.Path]sources: List[sbt.Path]List[Path]): Option[String]Option[String] =
		{
			List[sbt.Path]sources Option[String]match
			{
				Option[String]case sbt.Pathsrc :: List[sbt.Path]remaining =>
				{
					(sbt.Path)Option[String]doCopy(sbt.Pathsrc) Option[String]match
					{
						Option[String]case object NoneNone => (List[sbt.Path])Option[String]copy(List[sbt.Path]remaining)
						Option[String]case Option[String]error => Option[String]error
					}
				}
				None.typecase object NilNil => object NoneNone
			}
		}
		Option[String]creationError (=> Option[String])Option[String]orElse ( object sbt.ControlControl.(=> String,sbt.Logger)(=> Option[String])Option[String]trapUnit(java.lang.String("")"", sbt.Loggerlog) { (List[sbt.Path])Option[String]copy(Iterable[sbt.Path]sources.=> List[sbt.Path]toList) } )
	}
	/** Copies the files declared in <code>sources</code> to the <code>destinationDirectory</code>
	* directory.  Directories are not recursively entered.  The destination hierarchy matches the
	* source paths relative to any base directories.  For example:
	*
	* A source <code>(basePath ##) / x / y</code> is copied to <code>destinationDirectory / x / y</code>.
	* */
	def (Iterable[sbt.Path],sbt.Path,sbt.Logger)Either[String,scala.collection.Set[sbt.Path]] with Productcopy(Iterable[sbt.Path]sources: Iterable[sbt.Path]Iterable[Path], sbt.PathdestinationDirectory: sbt.PathPath, sbt.Loggerlog: sbt.LoggerLogger) =
	{
		val scala.collection.mutable.HashSet[sbt.Path]targetSet = scala.collection.mutable.HashSet[sbt.Path]new scala.collection.mutable.scala.collection.mutable.HashSet[sbt.Path]HashSet[Path]
		(Iterable[sbt.Path],sbt.Path,sbt.Logger)((sbt.Path) => Option[String])Option[String]copyImpl(Iterable[sbt.Path]sources, sbt.PathdestinationDirectory, sbt.Loggerlog)
		{
			sbt.Pathsource =>
			{
				val java.io.Filefrom = sbt.Pathsource.=> java.io.FileasFile
				val sbt.PathtoPath = object sbt.PathPath.(sbt.Path,String)sbt.PathfromString(sbt.PathdestinationDirectory, sbt.Pathsource.=> StringrelativePath)
				scala.collection.mutable.HashSet[sbt.Path]targetSet (sbt.Path)Unit+= sbt.PathtoPath
				val java.io.Fileto = sbt.PathtoPath.=> java.io.FileasFile
				Option[String]if(=> Boolean!java.io.Fileto.()Booleanexists (Boolean)Boolean|| java.io.Filefrom.()LonglastModified (Long)Boolean> java.io.Fileto.()LonglastModified)
				{
					Option[String]if(java.io.Filefrom.()BooleanisDirectory)
						(java.io.File,sbt.Logger)Option[String]createDirectory(java.io.Fileto, sbt.Loggerlog)
					else
					{
						sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Copying ")"Copying " (Any)java.lang.String+ sbt.Pathsource (Any)java.lang.String+ java.lang.String(" to ")" to " (Any)java.lang.String+ sbt.PathtoPath)
						(java.io.File,java.io.File,sbt.Logger)Option[String]copyFile(java.io.Filefrom, java.io.Fileto, sbt.Loggerlog)
					}
				}
				else
					object NoneNone
			}
		}.(=> scala.collection.Set[sbt.Path])Either[String,scala.collection.Set[sbt.Path]] with ProducttoLeft(scala.collection.mutable.HashSet[sbt.Path]targetSet.=> scala.collection.Set[sbt.Path]readOnly)
	}
	
	/** Copies the files declared in <code>sources</code> to the <code>targetDirectory</code>
	* directory.  The source directory hierarchy is flattened so that all copies are immediate
	* children of <code>targetDirectory</code>.  Directories are not recursively entered.*/
	def (Iterable[java.io.File],sbt.Path,sbt.Logger)Either[String,scala.collection.Set[sbt.Path]]copyFilesFlat(Iterable[java.io.File]sources: Iterable[java.io.File]Iterable[File], sbt.PathtargetDirectory: sbt.PathPath, sbt.Loggerlog: sbt.LoggerLogger) =
	{
		(Boolean,=> Any)Unitrequire(sbt.PathtargetDirectory.=> java.io.FileasFile.()BooleanisDirectory, java.lang.String("Target '")"Target '" (Any)java.lang.String+ sbt.PathtargetDirectory (Any)java.lang.String+ java.lang.String("' is not a directory.")"' is not a directory.")
		val scala.collection.mutable.HashMap[String,java.io.File]byName = scala.collection.mutable.HashMap[String,java.io.File]new scala.collection.mutable.scala.collection.mutable.HashMap[String,java.io.File]HashMap[String, File]
		for(((java.io.File) => Unit)Unitsource <- Iterable[java.io.File]sources) scala.collection.mutable.HashMap[String,java.io.File]byName.(String,java.io.File)Option[java.io.File]put(java.io.Filesource.()java.lang.StringgetName, java.io.Filesource)
		val Iterator[java.io.File]uniquelyNamedSources = scala.collection.mutable.HashMap[String,java.io.File]byName.=> Iterator[java.io.File]values
		val scala.collection.mutable.HashSet[sbt.Path]targetSet = scala.collection.mutable.HashSet[sbt.Path]new scala.collection.mutable.scala.collection.mutable.HashSet[sbt.Path]HashSet[Path]
		def (java.io.File)Option[String]copy(java.io.Filesource: java.io.FileFile): Option[String]Option[String] =
		{
			Option[String]if(java.io.Filesource.()BooleanisDirectory)
				(List[java.io.File])Option[String]copyAll(java.io.Filesource.()Array[java.io.File]listFiles.=> List[java.io.File]toList)
			else Option[String]if(java.io.Filesource.()Booleanexists)
			{
				val sbt.PathtargetPath = sbt.PathtargetDirectory (String)sbt.Path/ java.io.Filesource.()java.lang.StringgetName
				scala.collection.mutable.HashSet[sbt.Path]targetSet (sbt.Path)Unit+= sbt.PathtargetPath
				Option[String]if(=> Boolean!sbt.PathtargetPath.=> Booleanexists (Boolean)Boolean|| java.io.Filesource.()LonglastModified (Long)Boolean> sbt.PathtargetPath.=> LonglastModified)
				{
					sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Copying ")"Copying " (Any)java.lang.String+ java.io.Filesource (Any)java.lang.String+ java.lang.String(" to ")" to " (Any)java.lang.String+ sbt.PathtargetPath)
					(java.io.File,java.io.File,sbt.Logger)Option[String]copyFile(java.io.Filesource, sbt.PathtargetPath.=> java.io.FileasFile, sbt.Loggerlog)
				}
				else
					object NoneNone
			}
			else
				object NoneNone
		}
		def (List[java.io.File])Option[String]copyAll(List[java.io.File]sources: List[java.io.File]List[File]): Option[String]Option[String] =
			List[java.io.File]sources Option[String]match
			{
				Option[String]case java.io.Filehead :: List[java.io.File]tail =>
					(java.io.File)Option[String]copy(java.io.Filehead) Option[String]match
					{
						Option[String]case object NoneNone => (List[java.io.File])Option[String]copyAll(List[java.io.File]tail)
						Option[String]case Option[String]x => Option[String]x
					}
				None.typecase object NilNil => object NoneNone
			}
		
		object sbt.ControlControl.(=> String,sbt.Logger)(=> Either[String,scala.collection.Set[sbt.Path]])Either[String,scala.collection.Set[sbt.Path]]trap(java.lang.String("Error copying files: ")"Error copying files: ", sbt.Loggerlog) { (List[java.io.File])Option[String]copyAll(Iterator[java.io.File]uniquelyNamedSources.=> List[java.io.File]toList).(=> scala.collection.Set[sbt.Path])Either[String,scala.collection.Set[sbt.Path]] with ProducttoLeft(scala.collection.mutable.HashSet[sbt.Path]targetSet.=> scala.collection.Set[sbt.Path]readOnly) }
	}
	/** Copies <code>sourceFile</code> to <code>targetFile</code>.  If <code>targetFile</code>
	* exists, it is overwritten.  Note that unlike higher level copies in FileUtilities, this
	* method always performs the copy, even if sourceFile is older than targetFile.*/
	def (sbt.Path,sbt.Path,sbt.Logger)Option[String]copyFile(sbt.PathsourceFile: sbt.PathPath, sbt.PathtargetFile: sbt.PathPath, sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
		(java.io.File,java.io.File,sbt.Logger)Option[String]copyFile(sbt.PathsourceFile.=> java.io.FileasFile, sbt.PathtargetFile.=> java.io.FileasFile, sbt.Loggerlog)
	/** Copies <code>sourceFile</code> to <code>targetFile</code>.  If <code>targetFile</code>
	* exists, it is overwritten.  Note that unlike higher level copies in FileUtilities, this
	* method always performs the copy, even if sourceFile is older than targetFile.*/
	def (java.io.File,java.io.File,sbt.Logger)Option[String]copyFile(java.io.FilesourceFile: java.io.FileFile, java.io.FiletargetFile: java.io.FileFile, sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
	{
		(Boolean,=> Any)Unitrequire(java.io.FilesourceFile.()Booleanexists, java.lang.String("Source file '")"Source file '" (Any)java.lang.String+ java.io.FilesourceFile.()java.lang.StringgetAbsolutePath (Any)java.lang.String+ java.lang.String("' does not exist.")"' does not exist.")
		(Boolean,=> Any)Unitrequire(=> Boolean!java.io.FilesourceFile.()BooleanisDirectory, java.lang.String("Source file '")"Source file '" (Any)java.lang.String+ java.io.FilesourceFile.()java.lang.StringgetAbsolutePath (Any)java.lang.String+ java.lang.String("' is a directory.")"' is a directory.")
		(java.io.File,sbt.Logger)((java.nio.channels.FileChannel) => Option[String])Option[String]readChannel(java.io.FilesourceFile, sbt.Loggerlog)(
			java.nio.channels.FileChannelin => (java.io.File,sbt.Logger)((java.nio.channels.FileChannel) => Option[String])Option[String]writeChannel(java.io.FiletargetFile, sbt.Loggerlog) {
				java.nio.channels.FileChannelout => {
					val Longcopied = java.nio.channels.FileChannelout.(java.nio.channels.ReadableByteChannel,Long,Long)LongtransferFrom(java.nio.channels.FileChannelin, Long(0L)0, java.nio.channels.FileChannelin.()Longsize)
					Option[String]if(Longcopied (Long)Boolean== java.nio.channels.FileChannelin.()Longsize)
						object NoneNone
					else
						(java.lang.String)Some[java.lang.String]Some(java.lang.String("Could not copy '")"Could not copy '" (Any)java.lang.String+ java.io.FilesourceFile (Any)java.lang.String+ java.lang.String("' to '")"' to '" (Any)java.lang.String+ java.io.FiletargetFile (Any)java.lang.String+ java.lang.String("' (")"' (" (Any)java.lang.String+ Longcopied (Any)java.lang.String+ java.lang.String("/")"/" (Any)java.lang.String+ java.nio.channels.FileChannelin.()Longsize (Any)java.lang.String+ java.lang.String(" bytes copied)")" bytes copied)")
				}
			}
		)
	}
	
	/** Synchronizes the contents of the <code>sourceDirectory</code> directory to the
	* <code>targetDirectory</code> directory.*/
	def (sbt.Path,sbt.Path,sbt.Logger)Option[String]sync(sbt.PathsourceDirectory: sbt.PathPath, sbt.PathtargetDirectory: sbt.PathPath, sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
	{
		(Iterable[sbt.Path],sbt.Path,sbt.Logger)Either[String,scala.collection.Set[sbt.Path]] with Productcopy(((sbt.PathsourceDirectory => sbt.Path##) (sbt.FileFilter)sbt.PathFinder** object sbt.AllPassFilterAllPassFilter).=> scala.collection.Set[sbt.Path]get, sbt.PathtargetDirectory, sbt.Loggerlog).=> Either.RightProjection[String,scala.collection.Set[sbt.Path]]right.((scala.collection.Set[sbt.Path]) => Either[String,Unit])Either[String,Unit]flatMap
			{ scala.collection.Set[sbt.Path]copiedTo => (sbt.Path,Iterable[sbt.Path],sbt.Logger)Option[String]prune(sbt.PathtargetDirectory, scala.collection.Set[sbt.Path]copiedTo, sbt.Loggerlog).(=> Unit)Either[String,Unit] with ProducttoLeft(Unit()) }.=> Either.LeftProjection[String,Unit]left.=> Option[String]toOption
	}
	def (sbt.Path,Iterable[sbt.Path],sbt.Logger)Option[String]prune(sbt.Pathdirectory: sbt.PathPath, Iterable[sbt.Path]keepOnly: Iterable[sbt.Path]Iterable[Path], sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
	{
		val scala.collection.Set[sbt.Path]existing = ((sbt.Pathdirectory => sbt.Path##) (sbt.FileFilter)sbt.PathFinder** object sbt.AllPassFilterAllPassFilter).=> scala.collection.Set[sbt.Path]get
		val scala.collection.mutable.Set[sbt.Path]toRemove = scala.collection.mutable.(sbt.Path*)scala.collection.mutable.Set[sbt.Path]HashSet(scala.collection.Set[sbt.Path]existing.=> Seq[sbt.Path]toSeq: _*)
		scala.collection.mutable.Set[sbt.Path]toRemove (Iterable[sbt.Path])Unit--= Iterable[sbt.Path]keepOnly
		Unitif(sbt.Loggerlog.(sbt.Level.Value)BooleanatLevel(object sbt.LevelLevel.=> sbt.Level.ValueDebug))
			scala.collection.mutable.Set[sbt.Path]toRemove.((sbt.Path) => Unit)Unitforeach(sbt.Pathr => sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Pruning ")"Pruning " (Any)java.lang.String+ sbt.Pathr))
		(Iterable[sbt.Path],Boolean,sbt.Logger)Option[String]clean(scala.collection.mutable.Set[sbt.Path]toRemove, Boolean(true)true, sbt.Loggerlog)
	}
	
	/** Copies the contents of the <code>source</code> directory to the <code>target</code> directory .*/
	def (sbt.Path,sbt.Path,sbt.Logger)Option[String]copyDirectory(sbt.Pathsource: sbt.PathPath, sbt.Pathtarget: sbt.PathPath, sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
		(java.io.File,java.io.File,sbt.Logger)Option[String]copyDirectory(sbt.Pathsource.=> java.io.FileasFile, sbt.Pathtarget.=> java.io.FileasFile, sbt.Loggerlog)
	/** Copies the contents of the <code>source</code> directory to the <code>target</code> directory .*/
	def (java.io.File,java.io.File,sbt.Logger)Option[String]copyDirectory(java.io.Filesource: java.io.FileFile, java.io.Filetarget: java.io.FileFile, sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
	{
		(Boolean,=> Any)Unitrequire(java.io.Filesource.()BooleanisDirectory, java.lang.String("Source '")"Source '" (Any)java.lang.String+ java.io.Filesource.()java.lang.StringgetAbsolutePath (Any)java.lang.String+ java.lang.String("' is not a directory.")"' is not a directory.")
		(Boolean,=> Any)Unitrequire(=> Boolean!java.io.Filetarget.()Booleanexists, java.lang.String("Target '")"Target '" (Any)java.lang.String+ java.io.Filetarget.()java.lang.StringgetAbsolutePath (Any)java.lang.String+ java.lang.String("' already exists.")"' already exists.")
		def (java.io.File,java.io.File)Option[String]copyDirectory(java.io.FilesourceDir: java.io.FileFile, java.io.FiletargetDir: java.io.FileFile): Option[String]Option[String] =
			(java.io.File,sbt.Logger)Option[String]createDirectory(java.io.FiletargetDir, sbt.Loggerlog) (=> Option[String])Option[String]orElse (java.io.File,java.io.File)Option[String]copyContents(java.io.FilesourceDir, java.io.FiletargetDir)
		def (java.io.File,java.io.File)Option[String]copyContents(java.io.FilesourceDir: java.io.FileFile, java.io.FiletargetDir: java.io.FileFile): Option[String]Option[String] =
			java.io.FilesourceDir.()Array[java.io.File]listFiles.(Option[String])((Option[String], java.io.File) => Option[String])Option[String]foldLeft(object NoneNone: Option[String]Option[String])
			{
				(Option[String]result, java.io.Filefile) =>
					Option[String]result (=> Option[String])Option[String]orElse
					{
						val java.io.FiletargetFile = (java.io.File,java.lang.String)java.io.Filenew java.io.FileFile(java.io.FiletargetDir, java.io.Filefile.()java.lang.StringgetName)
						Option[String]if(java.io.Filefile.()BooleanisDirectory)
							(java.io.File,java.io.File)Option[String]copyDirectory(java.io.Filefile, java.io.FiletargetFile)
						else
							(java.io.File,java.io.File,sbt.Logger)Option[String]copyFile(java.io.Filefile, java.io.FiletargetFile, sbt.Loggerlog)
					}
			}
		(java.io.File,java.io.File)Option[String]copyDirectory(java.io.Filesource, java.io.Filetarget)
	}

	
	/** Deletes the given files recursively.*/
	def (Iterable[sbt.Path],sbt.Logger)Option[String]clean(Iterable[sbt.Path]files: Iterable[sbt.Path]Iterable[Path], sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] = (Iterable[sbt.Path],Boolean,sbt.Logger)Option[String]clean(Iterable[sbt.Path]files, Boolean(false)false, sbt.Loggerlog)
	/** Deletes the given files recursively.  <code>quiet</code> determines the logging level.
	* If it is true, each file in <code>files</code> is logged at the <code>info</code> level.
	* If it is false, the <code>debug</code> level is used.*/
	def (Iterable[sbt.Path],Boolean,sbt.Logger)Option[String]clean(Iterable[sbt.Path]files: Iterable[sbt.Path]Iterable[Path], Booleanquiet: BooleanBoolean, sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
		(Iterable[java.io.File],Boolean,sbt.Logger)Option[String]deleteFiles(Iterable[sbt.Path]files.((sbt.Path) => java.io.File)Iterable[java.io.File]map(sbt.Path_.=> java.io.FileasFile), Booleanquiet, sbt.Loggerlog)
			
	private def (Iterable[java.io.File],Boolean,sbt.Logger)Option[String]deleteFiles(Iterable[java.io.File]files: Iterable[java.io.File]Iterable[File], Booleanquiet: BooleanBoolean, sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
		((object NoneNone: Option[String]Option[String]) (Option[String])((Option[String], java.io.File) => Option[String])Option[String]/: Iterable[java.io.File]files)( (Option[String]result, java.io.Filefile) => Option[String]result (=> Option[String])Option[String]orElse (java.io.File,Boolean,sbt.Logger)Option[String]delete(java.io.Filefile, Booleanquiet, sbt.Loggerlog))
	private def (java.io.File,Boolean,sbt.Logger)Option[String]delete(java.io.Filefile: java.io.FileFile, Booleanquiet: BooleanBoolean, sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
	{
		def (=> String)UnitlogMessage(=> Stringmessage: => String)
		{
			sbt.Loggerlog.(sbt.Level.Value,=> String)Unitlog(sbt.Level.Valueif(Booleanquiet) object sbt.LevelLevel.=> sbt.Level.ValueDebug else object sbt.LevelLevel.=> sbt.Level.ValueInfo, => Stringmessage)
		}
		object sbt.ControlControl.(=> String,sbt.Logger)(=> Option[String])Option[String]trapUnit(java.lang.String("Error deleting file ")"Error deleting file " (Any)java.lang.String+ java.io.Filefile (Any)java.lang.String+ java.lang.String(": ")": ", sbt.Loggerlog)
		{
			AnyValif(java.io.Filefile.()BooleanisDirectory)
			{
				(=> String)UnitlogMessage(java.lang.String("Deleting directory ")"Deleting directory " (Any)java.lang.String+ java.io.Filefile)
				(Iterable[java.io.File],Boolean,sbt.Logger)Option[String]deleteFiles((Array[java.io.File])Array[java.io.File]wrapNull(java.io.Filefile.()Array[java.io.File]listFiles), Boolean(true)true, sbt.Loggerlog)
				java.io.Filefile.()Booleandelete
			}
			else AnyVal with NotNullif(java.io.Filefile.()Booleanexists)
			{
				(=> String)UnitlogMessage(java.lang.String("Deleting file ")"Deleting file " (Any)java.lang.String+ java.io.Filefile)
				java.io.Filefile.()Booleandelete
			}
			object NoneNone
		}
	}
	
	/** Appends the given <code>String content</code> to the provided <code>file</code> using the default encoding.
	* A new file is created if it does not exist.*/
	def (java.io.File,String,sbt.Logger)Option[String]append(java.io.Filefile: java.io.FileFile, Stringcontent: StringString, sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] = (java.io.File,String,java.nio.charset.Charset,sbt.Logger)Option[String]append(java.io.Filefile, Stringcontent, object java.nio.charset.CharsetCharset.()java.nio.charset.CharsetdefaultCharset, sbt.Loggerlog)
	/** Appends the given <code>String content</code> to the provided <code>file</code> using the given encoding.
	* A new file is created if it does not exist.*/
	def (java.io.File,String,java.nio.charset.Charset,sbt.Logger)Option[String]append(java.io.Filefile: java.io.FileFile, Stringcontent: StringString, java.nio.charset.Charsetcharset: java.nio.charset.CharsetCharset, sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
		(java.io.File,String,java.nio.charset.Charset,Boolean,sbt.Logger)Option[String]write(java.io.Filefile, Stringcontent, java.nio.charset.Charsetcharset, Boolean(true)true, sbt.Loggerlog)
	
	/** Writes the given <code>String content</code> to the provided <code>file</code> using the default encoding.
	* If the file exists, it is overwritten.*/
	def (java.io.File,String,sbt.Logger)Option[String]write(java.io.Filefile: java.io.FileFile, Stringcontent: StringString, sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] = (java.io.File,String,java.nio.charset.Charset,sbt.Logger)Option[String]write(java.io.Filefile, Stringcontent, object java.nio.charset.CharsetCharset.()java.nio.charset.CharsetdefaultCharset, sbt.Loggerlog)
	/** Writes the given <code>String content</code> to the provided <code>file</code> using the given encoding.
	* If the file already exists, it is overwritten.*/
	def (java.io.File,String,java.nio.charset.Charset,sbt.Logger)Option[String]write(java.io.Filefile: java.io.FileFile, Stringcontent: StringString, java.nio.charset.Charsetcharset: java.nio.charset.CharsetCharset, sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
		(java.io.File,String,java.nio.charset.Charset,Boolean,sbt.Logger)Option[String]write(java.io.Filefile, Stringcontent, java.nio.charset.Charsetcharset, Boolean(false)false, sbt.Loggerlog)
	private def (java.io.File,String,java.nio.charset.Charset,Boolean,sbt.Logger)Option[String]write(java.io.Filefile: java.io.FileFile, Stringcontent: StringString, java.nio.charset.Charsetcharset: java.nio.charset.CharsetCharset, Booleanappend: BooleanBoolean, sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
	{
		Option[String]if(java.nio.charset.Charsetcharset.()java.nio.charset.CharsetEncodernewEncoder.(java.lang.CharSequence)BooleancanEncode(Stringcontent))
			(java.io.File,java.nio.charset.Charset,Boolean,sbt.Logger)((java.io.Writer) => Option[String])Option[String]write(java.io.Filefile, java.nio.charset.Charsetcharset, Booleanappend, sbt.Loggerlog) { java.io.Writerw =>  java.io.Writerw.(java.lang.String)Unitwrite(Stringcontent); object NoneNone }
		else
			(java.lang.String)Some[java.lang.String]Some(java.lang.String("String cannot be encoded by default charset.")"String cannot be encoded by default charset.")
	}
	
	import OpenResource._
	
	/** Opens a <code>Writer</code> on the given file using the default encoding,
	* passes it to the provided function, and closes the <code>Writer</code>.*/
	def (java.io.File,sbt.Logger)((java.io.Writer) => Option[String])Option[String]write(java.io.Filefile: java.io.FileFile, sbt.Loggerlog: sbt.LoggerLogger)((java.io.Writer) => Option[String]f: Writer => Option[String]): Option[String]Option[String] =
		(java.io.File,java.nio.charset.Charset,sbt.Logger)((java.io.Writer) => Option[String])Option[String]write(java.io.Filefile, object java.nio.charset.CharsetCharset.()java.nio.charset.CharsetdefaultCharset, sbt.Loggerlog)((java.io.Writer) => Option[String]f)
	/** Opens a <code>Writer</code> on the given file using the given encoding,
	* passes it to the provided function, and closes the <code>Writer</code>.*/
	def (java.io.File,java.nio.charset.Charset,sbt.Logger)((java.io.Writer) => Option[String])Option[String]write(java.io.Filefile: java.io.FileFile, java.nio.charset.Charsetcharset: java.nio.charset.CharsetCharset, sbt.Loggerlog: sbt.LoggerLogger)((java.io.Writer) => Option[String]f: Writer => Option[String]): Option[String]Option[String] =
		(java.io.File,java.nio.charset.Charset,Boolean,sbt.Logger)((java.io.Writer) => Option[String])Option[String]write(java.io.Filefile, java.nio.charset.Charsetcharset, Boolean(false)false, sbt.Loggerlog)((java.io.Writer) => Option[String]f)
	private def (java.io.File,java.nio.charset.Charset,Boolean,sbt.Logger)((java.io.Writer) => Option[String])Option[String]write(java.io.Filefile: java.io.FileFile, java.nio.charset.Charsetcharset: java.nio.charset.CharsetCharset, Booleanappend: BooleanBoolean, sbt.Loggerlog: sbt.LoggerLogger)((java.io.Writer) => Option[String]f: Writer => Option[String]): Option[String]Option[String] =
		(java.nio.charset.Charset,Boolean)sbt.OpenFile[java.io.Writer]fileWriter(java.nio.charset.Charsetcharset, Booleanappend).(java.io.File,String,sbt.Logger)((java.io.Writer) => Option[String])Option[String]ioOption(java.io.Filefile, java.lang.String("writing")"writing", sbt.Loggerlog)((java.io.Writer) => Option[String]f)
		
	/** Opens a <code>Reader</code> on the given file using the default encoding,
	* passes it to the provided function, and closes the <code>Reader</code>.*/
	def (java.io.File,sbt.Logger)((java.io.Reader) => Option[String])Option[String]read(java.io.Filefile: java.io.FileFile, sbt.Loggerlog: sbt.LoggerLogger)((java.io.Reader) => Option[String]f: Reader => Option[String]): Option[String]Option[String] =
		(java.io.File,java.nio.charset.Charset,sbt.Logger)((java.io.Reader) => Option[String])Option[String]read(java.io.Filefile, object java.nio.charset.CharsetCharset.()java.nio.charset.CharsetdefaultCharset, sbt.Loggerlog)((java.io.Reader) => Option[String]f)
	/** Opens a <code>Reader</code> on the given file using the default encoding,
	* passes it to the provided function, and closes the <code>Reader</code>.*/
	def (java.io.File,java.nio.charset.Charset,sbt.Logger)((java.io.Reader) => Option[String])Option[String]read(java.io.Filefile: java.io.FileFile, java.nio.charset.Charsetcharset: java.nio.charset.CharsetCharset, sbt.Loggerlog: sbt.LoggerLogger)((java.io.Reader) => Option[String]f: Reader => Option[String]): Option[String]Option[String] =
		(java.nio.charset.Charset)sbt.OpenFile[java.io.Reader]fileReader(java.nio.charset.Charsetcharset).(java.io.File,String,sbt.Logger)((java.io.Reader) => Option[String])Option[String]ioOption(java.io.Filefile, java.lang.String("reading")"reading", sbt.Loggerlog)((java.io.Reader) => Option[String]f)
	/** Opens a <code>Reader</code> on the given file using the default encoding,
	* passes it to the provided function, and closes the <code>Reader</code>.*/
	def [R](java.io.File,sbt.Logger)((java.io.Reader) => Either[String,R])Either[String,R]readValue[>: Nothing <: AnyR](java.io.Filefile: java.io.FileFile, sbt.Loggerlog: sbt.LoggerLogger)((java.io.Reader) => Either[String,R]f: Reader => Either[String, R]): Either[String,R]Either[String, R] =
		(java.io.File,java.nio.charset.Charset,sbt.Logger)((java.io.Reader) => Either[String,R])Either[String,R]readValue(java.io.Filefile, object java.nio.charset.CharsetCharset.()java.nio.charset.CharsetdefaultCharset, sbt.Loggerlog)((java.io.Reader) => Either[String,R]f)
	/** Opens a <code>Reader</code> on the given file using the given encoding,
	* passes it to the provided function, and closes the <code>Reader</code>.*/
	def [R](java.io.File,java.nio.charset.Charset,sbt.Logger)((java.io.Reader) => Either[String,R])Either[String,R]readValue[>: Nothing <: AnyR](java.io.Filefile: java.io.FileFile, java.nio.charset.Charsetcharset: java.nio.charset.CharsetCharset, sbt.Loggerlog: sbt.LoggerLogger)((java.io.Reader) => Either[String,R]f: Reader => Either[String, R]): Either[String,R]Either[String, R] =
		(java.nio.charset.Charset)sbt.OpenFile[java.io.Reader]fileReader(java.nio.charset.Charsetcharset).(java.io.File,String,sbt.Logger)((java.io.Reader) => Either[String,R])Either[String,R]io(java.io.Filefile, java.lang.String("reading")"reading", sbt.Loggerlog)((java.io.Reader) => Either[String,R]f)
		
	/** Reads the contents of the given file into a <code>String</code> using the default encoding.
	*  The resulting <code>String</code> is wrapped in <code>Right</code>.*/
	def (java.io.File,sbt.Logger)Either[String,String]readString(java.io.Filefile: java.io.FileFile, sbt.Loggerlog: sbt.LoggerLogger): Either[String,String]Either[String, String] = (java.io.File,java.nio.charset.Charset,sbt.Logger)Either[String,String]readString(java.io.Filefile, object java.nio.charset.CharsetCharset.()java.nio.charset.CharsetdefaultCharset, sbt.Loggerlog)
	/** Reads the contents of the given file into a <code>String</code> using the given encoding.
	*  The resulting <code>String</code> is wrapped in <code>Right</code>.*/
	def (java.io.File,java.nio.charset.Charset,sbt.Logger)Either[String,String]readString(java.io.Filefile: java.io.FileFile, java.nio.charset.Charsetcharset: java.nio.charset.CharsetCharset, sbt.Loggerlog: sbt.LoggerLogger): Either[String,String]Either[String, String] =
	{
		(java.io.File,java.nio.charset.Charset,sbt.Logger)((java.io.Reader) => Either[String,String])Either[String,String]readValue(java.io.Filefile, java.nio.charset.Charsetcharset, sbt.Loggerlog) {
			java.io.Readerin =>
			{
				val StringBuilderbuilder = ()StringBuildernew StringBuilderStringBuilder
				val Array[Char]buffer = Array[Char]new Array[Char]Array[Char](=> IntBufferSize)
				def ()UnitreadNext()
				{
					val Intread = java.io.Readerin.(Array[Char],Int,Int)Intread(Array[Char]buffer, Int(0)0, Array[Char]buffer.=> Intlength)
					Unitif(Intread (Int)Boolean>= Int(0)0)
					{
						StringBuilderbuilder.(Array[Char],Int,Int)StringBuilderappend(Array[Char]buffer, Int(0)0, Intread)
						()UnitreadNext()
					}
					else
						object NoneNone
				}
				()UnitreadNext()
				(String)Right[Nothing,String]Right(StringBuilderbuilder.()StringtoString)
			}
		}
	}
	/** Appends the given bytes to the given file. */
	def (java.io.File,Array[Byte],sbt.Logger)Option[String]append(java.io.Filefile: java.io.FileFile, Array[Byte]bytes: Array[Byte]Array[Byte], sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
		(java.io.File,Array[Byte],Boolean,sbt.Logger)Option[String]writeBytes(java.io.Filefile, Array[Byte]bytes, Boolean(true)true, sbt.Loggerlog)
	/** Writes the given bytes to the given file. If the file already exists, it is overwritten.*/
	def (java.io.File,Array[Byte],sbt.Logger)Option[String]write(java.io.Filefile: java.io.FileFile, Array[Byte]bytes: Array[Byte]Array[Byte], sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
		(java.io.File,Array[Byte],Boolean,sbt.Logger)Option[String]writeBytes(java.io.Filefile, Array[Byte]bytes, Boolean(false)false, sbt.Loggerlog)
	private def (java.io.File,Array[Byte],Boolean,sbt.Logger)Option[String]writeBytes(java.io.Filefile: java.io.FileFile, Array[Byte]bytes: Array[Byte]Array[Byte], Booleanappend: BooleanBoolean, sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
		(java.io.File,Boolean,sbt.Logger)((java.io.OutputStream) => Option[String])Option[String]writeStream(java.io.Filefile, Booleanappend, sbt.Loggerlog) { java.io.OutputStreamout => java.io.OutputStreamout.(Array[Byte])Unitwrite(Array[Byte]bytes); object NoneNone }
	
	/** Reads the entire file into a byte array. */
	def (java.io.File,sbt.Logger)Either[String,Array[Byte]]readBytes(java.io.Filefile: java.io.FileFile, sbt.Loggerlog: sbt.LoggerLogger): Either[String,Array[Byte]]Either[String, Array[Byte]] =
		(java.io.File,sbt.Logger)((java.io.InputStream) => Either[String,Array[Byte]])Either[String,Array[Byte]]readStreamValue(java.io.Filefile, sbt.Loggerlog)
		{ java.io.InputStreamin =>
			val java.io.ByteArrayOutputStreamout = java.io.ByteArrayOutputStreamnew java.io.ByteArrayOutputStreamByteArrayOutputStream
			val Array[Byte]buffer = Array[Byte]new Array[Byte]Array[Byte](=> IntBufferSize)
			def ()UnitreadNext()
			{
				val Intread = java.io.InputStreamin.(Array[Byte])Intread(Array[Byte]buffer)
				Unitif(Intread (Int)Boolean>= Int(0)0)
				{
					java.io.ByteArrayOutputStreamout.(Array[Byte],Int,Int)Unitwrite(Array[Byte]buffer, Int(0)0, Intread)
					()UnitreadNext()
				}
			}
			()UnitreadNext()
			(Array[Byte])Right[Nothing,Array[Byte]]Right(java.io.ByteArrayOutputStreamout.()Array[Byte]toByteArray)
		}
		
	/** Opens an <code>OutputStream</code> on the given file with append=true and passes the stream
	* to the provided function.  The stream is closed before this function returns.*/
	def (java.io.File,sbt.Logger)((java.io.OutputStream) => Option[String])Option[String]appendStream(java.io.Filefile: java.io.FileFile, sbt.Loggerlog: sbt.LoggerLogger)((java.io.OutputStream) => Option[String]f: OutputStream => Option[String]): Option[String]Option[String] =
		(Boolean)sbt.OpenFile[java.io.FileOutputStream]fileOutputStream(Boolean(true)true).(java.io.File,String,sbt.Logger)((java.io.FileOutputStream) => Option[String])Option[String]ioOption(java.io.Filefile, java.lang.String("appending")"appending", sbt.Loggerlog)((java.io.OutputStream) => Option[String]f)
	/** Opens an <code>OutputStream</code> on the given file and passes the stream
	* to the provided function.  The stream is closed before this function returns.*/
	def (java.io.File,sbt.Logger)((java.io.OutputStream) => Option[String])Option[String]writeStream(java.io.Filefile: java.io.FileFile, sbt.Loggerlog: sbt.LoggerLogger)((java.io.OutputStream) => Option[String]f: OutputStream => Option[String]): Option[String]Option[String] =
		(Boolean)sbt.OpenFile[java.io.FileOutputStream]fileOutputStream(Boolean(false)false).(java.io.File,String,sbt.Logger)((java.io.FileOutputStream) => Option[String])Option[String]ioOption(java.io.Filefile, java.lang.String("writing")"writing", sbt.Loggerlog)((java.io.OutputStream) => Option[String]f)
	private def (java.io.File,Boolean,sbt.Logger)((java.io.OutputStream) => Option[String])Option[String]writeStream(java.io.Filefile: java.io.FileFile, Booleanappend: BooleanBoolean, sbt.Loggerlog: sbt.LoggerLogger)((java.io.OutputStream) => Option[String]f: OutputStream => Option[String]): Option[String]Option[String] =
		Option[String]if(Booleanappend) (java.io.File,sbt.Logger)((java.io.OutputStream) => Option[String])Option[String]appendStream(java.io.Filefile, sbt.Loggerlog)((java.io.OutputStream) => Option[String]f) else (java.io.File,sbt.Logger)((java.io.OutputStream) => Option[String])Option[String]writeStream(java.io.Filefile, sbt.Loggerlog)((java.io.OutputStream) => Option[String]f)
	/** Opens an <code>InputStream</code> on the given file and passes the stream
	* to the provided function.  The stream is closed before this function returns.*/
	def (java.io.File,sbt.Logger)((java.io.InputStream) => Option[String])Option[String]readStream(java.io.Filefile: java.io.FileFile, sbt.Loggerlog: sbt.LoggerLogger)((java.io.InputStream) => Option[String]f: InputStream => Option[String]): Option[String]Option[String] =
		=> sbt.OpenFile[java.io.FileInputStream]fileInputStream.(java.io.File,String,sbt.Logger)((java.io.FileInputStream) => Option[String])Option[String]ioOption(java.io.Filefile, java.lang.String("reading")"reading", sbt.Loggerlog)((java.io.InputStream) => Option[String]f)
	/** Opens an <code>InputStream</code> on the given file and passes the stream
	* to the provided function.  The stream is closed before this function returns.*/
	def [R](java.io.File,sbt.Logger)((java.io.InputStream) => Either[String,R])Either[String,R]readStreamValue[>: Nothing <: AnyR](java.io.Filefile: java.io.FileFile, sbt.Loggerlog: sbt.LoggerLogger)((java.io.InputStream) => Either[String,R]f: InputStream => Either[String, R]): Either[String,R]Either[String, R] =
		=> sbt.OpenFile[java.io.FileInputStream]fileInputStream.(java.io.File,String,sbt.Logger)((java.io.FileInputStream) => Either[String,R])Either[String,R]io(java.io.Filefile, java.lang.String("reading")"reading", sbt.Loggerlog)((java.io.InputStream) => Either[String,R]f)
	/** Opens an <code>InputStream</code> on the given <code>URL</code> and passes the stream
	* to the provided function.  The stream is closed before this function returns.*/
	def (java.net.URL,sbt.Logger)((java.io.InputStream) => Option[String])Option[String]readStream(java.net.URLurl: java.net.URLURL, sbt.Loggerlog: sbt.LoggerLogger)((java.io.InputStream) => Option[String]f: InputStream => Option[String]): Option[String]Option[String] =
		=> sbt.OpenResource[java.net.URL,java.io.InputStream]urlInputStream.(java.net.URL,String,sbt.Logger)((java.io.InputStream) => Option[String])Option[String]ioOption(java.net.URLurl, java.lang.String("reading")"reading", sbt.Loggerlog)((java.io.InputStream) => Option[String]f)
	/** Opens an <code>InputStream</code> on the given <code>URL</code> and passes the stream
	* to the provided function.  The stream is closed before this function returns.*/
	def [R](java.net.URL,sbt.Logger)((java.io.InputStream) => Either[String,R])Either[String,R]readStreamValue[>: Nothing <: AnyR](java.net.URLurl: java.net.URLURL, sbt.Loggerlog: sbt.LoggerLogger)((java.io.InputStream) => Either[String,R]f: InputStream => Either[String, R]): Either[String,R]Either[String, R] =
		=> sbt.OpenResource[java.net.URL,java.io.InputStream]urlInputStream.(java.net.URL,String,sbt.Logger)((java.io.InputStream) => Either[String,R])Either[String,R]io(java.net.URLurl, java.lang.String("reading")"reading", sbt.Loggerlog)((java.io.InputStream) => Either[String,R]f)
		
	/** Opens a <code>FileChannel</code> on the given file for writing and passes the channel
	* to the given function.  The channel is closed before this function returns.*/
	def (java.io.File,sbt.Logger)((java.nio.channels.FileChannel) => Option[String])Option[String]writeChannel(java.io.Filefile: java.io.FileFile, sbt.Loggerlog: sbt.LoggerLogger)((java.nio.channels.FileChannel) => Option[String]f: FileChannel => Option[String]): Option[String]Option[String] =
		=> sbt.OpenFile[java.nio.channels.FileChannel]fileOutputChannel.(java.io.File,String,sbt.Logger)((java.nio.channels.FileChannel) => Option[String])Option[String]ioOption(java.io.Filefile, java.lang.String("writing")"writing", sbt.Loggerlog)((java.nio.channels.FileChannel) => Option[String]f)
	/** Opens a <code>FileChannel</code> on the given file for reading and passes the channel
	* to the given function.  The channel is closed before this function returns.*/
	def (java.io.File,sbt.Logger)((java.nio.channels.FileChannel) => Option[String])Option[String]readChannel(java.io.Filefile: java.io.FileFile, sbt.Loggerlog: sbt.LoggerLogger)((java.nio.channels.FileChannel) => Option[String]f: FileChannel => Option[String]): Option[String]Option[String] =
		=> sbt.OpenFile[java.nio.channels.FileChannel]fileInputChannel.(java.io.File,String,sbt.Logger)((java.nio.channels.FileChannel) => Option[String])Option[String]ioOption(java.io.Filefile, java.lang.String("reading")"reading", sbt.Loggerlog)((java.nio.channels.FileChannel) => Option[String]f)
	/** Opens a <code>FileChannel</code> on the given file for reading and passes the channel
	* to the given function.  The channel is closed before this function returns.*/
	def [R](java.io.File,sbt.Logger)((java.nio.channels.FileChannel) => Either[String,R])Either[String,R]readChannelValue[>: Nothing <: AnyR](java.io.Filefile: java.io.FileFile, sbt.Loggerlog: sbt.LoggerLogger)((java.nio.channels.FileChannel) => Either[String,R]f: FileChannel => Either[String, R]): Either[String,R]Either[String, R] =
		=> sbt.OpenFile[java.nio.channels.FileChannel]fileInputChannel.(java.io.File,String,sbt.Logger)((java.nio.channels.FileChannel) => Either[String,R])Either[String,R]io(java.io.Filefile, java.lang.String("reading")"reading", sbt.Loggerlog)((java.nio.channels.FileChannel) => Either[String,R]f)
	
	private[sbt] def (Array[java.io.File])Array[java.io.File]wrapNull(Array[java.io.File]a: Array[java.io.File]Array[File]): Array[java.io.File]Array[File] =
		Array[java.io.File]if(Array[java.io.File]a (AnyRef)Boolean== Null(null)null)
			Array[java.io.File]new Array[java.io.File]Array[File](Int(0)0)
		else
			Array[java.io.File]a
			
	/** Writes the given string to the writer followed by a newline.*/
	private[sbt] def (java.io.Writer,String)UnitwriteLine(java.io.Writerwriter: java.io.WriterWriter, Stringline: StringString)
	{
		java.io.Writerwriter.(java.lang.String)Unitwrite(Stringline)
		java.io.Writerwriter.(java.lang.String)Unitwrite(=> java.lang.StringNewline)
	}
	
	/** The directory in which temporary files are placed.*/
	val java.io.FiletemporaryDirectory = java.io.Filenew java.io.FileFile(object java.lang.SystemSystem.(java.lang.String)java.lang.StringgetProperty(java.lang.String("java.io.tmpdir")"java.io.tmpdir"))
	/** The location of the jar containing this class.*/
	lazy val java.io.FilesbtJar: java.io.FileFile = (java.net.URI)java.io.Filenew java.io.FileFile(()java.lang.Class[_ <: java.lang.Object]getClass.()java.security.ProtectionDomaingetProtectionDomain.()java.security.CodeSourcegetCodeSource.()java.net.URLgetLocation.()java.net.URItoURI)
	/** The producer of randomness for unique name generation.*/
	private val java.util.Randomrandom = java.util.Randomnew java.util.java.util.RandomRandom
}
class class CloseableJarFile extends java.util.jar.JarFile with java.io.Closeable with ScalaObjectCloseableJarFile(java.io.Filef: java.io.FileFile, Booleanverify: BooleanBoolean) extends java.util.jar.JarFileJarFile(java.io.Filef, Booleanverify) with java.io.CloseableCloseable
{
	def (java.io.File)sbt.CloseableJarFilethis(java.io.Filef: java.io.FileFile) = CloseableJarFile.this.typethis(java.io.Filef, Boolean(false)false)
}

private abstract class class OpenResource[Source, T <: java.io.Closeable] extends java.lang.Object with NotNull with ScalaObjectOpenResource[>: Nothing <: AnySource, >: Nothing <: java.io.CloseableT <: Closeable] extends NotNullNotNull
{
	import OpenResource.{unwrapEither, wrapEither}
	protected def (Source,sbt.Logger)Either[String,T]open(Sourcesrc: SourceSource, sbt.Loggerlog: sbt.LoggerLogger): Either[String,T]Either[String, T]
	def (Source,String,sbt.Logger)((T) => Option[String])Option[String]ioOption(Sourcesrc: SourceSource, Stringop: StringString, sbt.Loggerlog: sbt.LoggerLogger)((T) => Option[String]f: T => Option[String]) =
		(Either[String,Unit])Option[String]unwrapEither( (Source,String,sbt.Logger)((T) => Either[String,Unit])Either[String,Unit]io(Sourcesrc, Stringop, sbt.Loggerlog)(((T) => Option[String])(T) => Either[String,Unit]wrapEither((T) => Option[String]f)) )
	def [R](Source,String,sbt.Logger)((T) => Either[String,R])Either[String,R]io[>: Nothing <: AnyR](Sourcesrc: SourceSource, Stringop: StringString, sbt.Loggerlog: sbt.LoggerLogger)((T) => Either[String,R]f: T => Either[String,R]): Either[String,R]Either[String, R] =
		(Source,sbt.Logger)Either[String,T]open(Sourcesrc, sbt.Loggerlog).=> Either.RightProjection[String,T]right ((T) => Either[String,R])Either[String,R]flatMap
		{
			Tresource => object sbt.ControlControl.(=> String,sbt.Logger)(=> Either[String,R])(=> Unit)Either[String,R]trapAndFinally(java.lang.String("Error ")"Error " (Any)java.lang.String+ Stringop (Any)java.lang.String+ java.lang.String(" ")" "(Any)java.lang.String+ Sourcesrc (Any)java.lang.String+ java.lang.String(": ")": ", sbt.Loggerlog)
				{ (T)Either[String,R]f(Tresource) }
				{ Tresource.()Unitclose }
		}
}
private abstract class class OpenFile[T <: java.io.Closeable] extends sbt.OpenResource[java.io.File,T] with ScalaObjectOpenFile[>: Nothing <: java.io.CloseableT <: Closeable] extends sbt.OpenResource[java.io.File,T]OpenResource[File, T]
{
	protected def (java.io.File)Topen(java.io.Filefile: java.io.FileFile): TT
	protected final def (java.io.File,sbt.Logger)Either[String,T]open(java.io.Filefile: java.io.FileFile, sbt.Loggerlog: sbt.LoggerLogger): Either[String,T]Either[String, T] =
	{
		val java.io.Fileparent = java.io.Filefile.()java.io.FilegetParentFile
		Anyif(java.io.Fileparent (AnyRef)Boolean!= Null(null)null)
			object sbt.FileUtilitiesFileUtilities.(java.io.File,sbt.Logger)Option[String]createDirectory(java.io.Fileparent, sbt.Loggerlog)
		object sbt.ControlControl.(=> String,sbt.Logger)(=> Either[String,T])Either[String,T]trap(java.lang.String("Error opening ")"Error opening " (Any)java.lang.String+ java.io.Filefile (Any)java.lang.String+ java.lang.String(": ")": ", sbt.Loggerlog) { (T)Right[Nothing,T]Right((java.io.File)Topen(java.io.Filefile)) }
	}
}
private object object sbt.OpenResourceOpenResource
{
	private def [R]((R) => Option[String])(R) => Either[String,Unit]wrapEither[>: Nothing <: AnyR]((R) => Option[String]f: R => Option[String]): (R => Either[String, Unit]) = (Rr: RR) => (R)Option[String]f(Rr).(=> Unit)Either[String,Unit] with ProducttoLeft(Unit())
	private def (Either[String,Unit])Option[String]unwrapEither(Either[String,Unit]e: Either[String,Unit]Either[String, Unit]): Option[String]Option[String] = Either[String,Unit]e.=> Either.LeftProjection[String,Unit]left.=> Option[String]toOption
	
	def (Boolean)sbt.OpenFile[java.io.FileOutputStream]fileOutputStream(Booleanappend: BooleanBoolean) =
		template $anon extends sbt.OpenFile[java.io.FileOutputStream]new sbt.OpenFile[java.io.FileOutputStream]OpenFile[FileOutputStream] { protected def (java.io.File)java.io.FileOutputStreamopen(java.io.Filefile: java.io.FileFile) = (java.io.File,Boolean)java.io.FileOutputStreamnew java.io.FileOutputStreamFileOutputStream(java.io.Filefile, Booleanappend) }
	def => sbt.OpenFile[java.io.FileInputStream]fileInputStream = template $anon extends sbt.OpenFile[java.io.FileInputStream]new sbt.OpenFile[java.io.FileInputStream]OpenFile[FileInputStream]
		{ protected def (java.io.File)java.io.FileInputStreamopen(java.io.Filefile: java.io.FileFile) = (java.io.File)java.io.FileInputStreamnew java.io.FileInputStreamFileInputStream(java.io.Filefile) }
	def => sbt.OpenResource[java.net.URL,java.io.InputStream]urlInputStream = template $anon extends sbt.OpenResource[java.net.URL,java.io.InputStream]new sbt.OpenResource[java.net.URL,java.io.InputStream]OpenResource[URL, InputStream]
		{ protected def (java.net.URL,sbt.Logger)Either[String,java.io.InputStream]open(java.net.URLurl: java.net.URLURL, sbt.Loggerlog: sbt.LoggerLogger) = object sbt.ControlControl.(=> String,sbt.Logger)(=> Either[String,java.io.InputStream])Either[String,java.io.InputStream]trap(java.lang.String("Error opening ")"Error opening " (Any)java.lang.String+ java.net.URLurl (Any)java.lang.String+ java.lang.String(": ")": ", sbt.Loggerlog) { (java.io.InputStream)Right[Nothing,java.io.InputStream]Right(java.net.URLurl.()java.io.InputStreamopenStream) } }
	def => sbt.OpenFile[java.nio.channels.FileChannel]fileOutputChannel = template $anon extends sbt.OpenFile[java.nio.channels.FileChannel]new sbt.OpenFile[java.nio.channels.FileChannel]OpenFile[FileChannel]
		{ protected def (java.io.File)java.nio.channels.FileChannelopen(java.io.Filef: java.io.FileFile) = ((java.io.File)java.io.FileOutputStreamnew java.io.FileOutputStreamFileOutputStream(java.io.Filef)).()java.nio.channels.FileChannelgetChannel }
	def => sbt.OpenFile[java.nio.channels.FileChannel]fileInputChannel = template $anon extends sbt.OpenFile[java.nio.channels.FileChannel]new sbt.OpenFile[java.nio.channels.FileChannel]OpenFile[FileChannel]
		{ protected def (java.io.File)java.nio.channels.FileChannelopen(java.io.Filef: java.io.FileFile) = ((java.io.File)java.io.FileInputStreamnew java.io.FileInputStreamFileInputStream(java.io.Filef)).()java.nio.channels.FileChannelgetChannel }
	def (java.nio.charset.Charset,Boolean)sbt.OpenFile[java.io.Writer]fileWriter(java.nio.charset.Charsetcharset: java.nio.charset.CharsetCharset, Booleanappend: BooleanBoolean) = template $anon extends sbt.OpenFile[java.io.Writer]new sbt.OpenFile[java.io.Writer]OpenFile[Writer]
		{ protected def (java.io.File)java.io.BufferedWriteropen(java.io.Filef: java.io.FileFile) = java.io.BufferedWriternew java.io.BufferedWriterBufferedWriter((java.io.OutputStream,java.nio.charset.Charset)java.io.OutputStreamWriternew java.io.OutputStreamWriterOutputStreamWriter((java.io.File,Boolean)java.io.FileOutputStreamnew java.io.FileOutputStreamFileOutputStream(java.io.Filef, Booleanappend), java.nio.charset.Charsetcharset)) }
	def (java.nio.charset.Charset)sbt.OpenFile[java.io.Reader]fileReader(java.nio.charset.Charsetcharset: java.nio.charset.CharsetCharset) = template $anon extends sbt.OpenFile[java.io.Reader]new sbt.OpenFile[java.io.Reader]OpenFile[Reader]
		{ protected def (java.io.File)java.io.BufferedReaderopen(java.io.Filef: java.io.FileFile) = (java.io.Reader)java.io.BufferedReadernew java.io.BufferedReaderBufferedReader((java.io.InputStream,java.nio.charset.Charset)java.io.InputStreamReadernew java.io.InputStreamReaderInputStreamReader((java.io.File)java.io.FileInputStreamnew java.io.FileInputStreamFileInputStream(java.io.Filef), java.nio.charset.Charsetcharset)) }
	def (Boolean)sbt.OpenFile[sbt.CloseableJarFile]openJarFile(Booleanverify: BooleanBoolean) = template $anon extends sbt.OpenFile[sbt.CloseableJarFile]new sbt.OpenFile[sbt.CloseableJarFile]OpenFile[CloseableJarFile]
		{ protected def (java.io.File)sbt.CloseableJarFileopen(java.io.Filef: java.io.FileFile) = sbt.CloseableJarFilenew sbt.CloseableJarFileCloseableJarFile(java.io.Filef, Booleanverify) }
}