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

import Path._
import FileUtilities.wrapNull
import java.io.File
import scala.collection.mutable.{Set, HashSet}

/** A Path represents a file in a project.
* @see sbt.PathFinder*/
sealed abstract class class Path extends sbt.PathFinder with NotNull with ScalaObjectPath extends sbt.PathFinderPathFinder with NotNullNotNull
{
	/** Creates a base directory for this path.  This is used by copy and zip functions
	* to determine the relative path that should be used in the destination.  For example,
	* if the following path is specified to be copied to directory 'd',
	* 
	* <code>((a / b) ##) / x / y</code>
	*
	* the copied path would be 
	*
	* <code>d / x / y</code>
	*
	* The <code>relativePath</code> method is used to return the relative path to the base directory. */
	override def => sbt.Path## : sbt.PathPath = sbt.BaseDirectorynew sbt.BaseDirectoryBaseDirectory(sbt.Paththis)
	private[sbt] def (scala.collection.mutable.Set[sbt.Path])UnitaddTo(scala.collection.mutable.Set[sbt.Path]pathSet: scala.collection.mutable.Set[sbt.Path]Set[Path])
	{
		Unitif(=> java.io.FileasFile.()Booleanexists)
			scala.collection.mutable.Set[sbt.Path]pathSet (sbt.Path)Unit+= sbt.Paththis
	}
	override def (String)sbt.Path/ (Stringcomponent: StringString): sbt.PathPath = sbt.Pathif(Stringcomponent (AnyRef)Boolean== java.lang.String(".")".") sbt.Paththis else sbt.RelativePathnew sbt.RelativePathRelativePath(sbt.Paththis, Stringcomponent)
	/** True if and only if the file represented by this path exists.*/
	def => Booleanexists = => java.io.FileasFile.()Booleanexists
	/** True if and only if the file represented by this path is a directory.*/
	def => BooleanisDirectory = => java.io.FileasFile.()BooleanisDirectory
	/** The last modified time of the file represented by this path.*/
	def => LonglastModified = => java.io.FileasFile.()LonglastModified
	/* True if and only if file that this path represents exists and the file represented by the path 'p'
	* does not exist or was modified before the file for this path.*/
	def (sbt.Path)BooleannewerThan(sbt.Pathp: sbt.PathPath): BooleanBoolean = => Booleanexists (Boolean)Boolean&& (=> Boolean!sbt.Pathp.=> Booleanexists (Boolean)Boolean|| => LonglastModified (Long)Boolean> sbt.Pathp.=> LonglastModified)
	/* True if and only if file that this path represents does not exist or the file represented by the path 'p'
	* exists and was modified after the file for this path.*/
	def (sbt.Path)BooleanolderThan(sbt.Pathp: sbt.PathPath): BooleanBoolean = sbt.Pathp (sbt.Path)BooleannewerThan sbt.Paththis
	/** The file represented by this path.*/
	def => java.io.FileasFile: java.io.FileFile
	/** The file represented by this path converted to a <code>URL</code>.*/
	def => java.net.URLasURL = => java.io.FileasFile.()java.net.URItoURI.()java.net.URLtoURL
	/** The string representation of this path relative to the base directory.  The project directory is the
	* default base directory if one is not specified explicitly using the <code>##</code> operator.*/
	def => StringrelativePath: StringString
	def => StringabsolutePath: StringString = => java.io.FileasFile.()java.lang.StringgetAbsolutePath
	private[sbt] def (String)StringprependTo(Strings: StringString): StringString
	
	/** Equality of Paths is defined in terms of the underlying <code>File</code>.*/
	override final def (Any)Booleanequals(Anyother: AnyAny) =
		Anyother Booleanmatch
		{
			Booleancase sbt.Pathop: sbt.PathPath => => java.io.FileasFile (AnyRef)Boolean== sbt.Pathop.=> java.io.FileasFile
			Boolean(false)case _ => Boolean(false)false
		}
	/** The hash code of a Path is that of the underlying <code>File</code>.*/
	override final def ()InthashCode = => java.io.FileasFile.()InthashCode
}
private final class class BaseDirectory extends sbt.Path with ScalaObjectBaseDirectory(private[sbt] val sbt.Pathpath: sbt.PathPath) extends sbt.PathPath
{
	override def ()java.lang.StringtoString = => sbt.Pathpath.()java.lang.StringtoString
	def => java.io.FileasFile = => sbt.Pathpath.=> java.io.FileasFile
	def => java.lang.StringrelativePath = java.lang.String("")""
	private[sbt] def (String)java.lang.StringprependTo(Strings: StringString) = java.lang.String(".")"." (Any)java.lang.String+ => Charsep (Any)java.lang.String+ Strings
}
private[sbt] final class class ProjectDirectory extends sbt.Path with ScalaObjectProjectDirectory(val java.io.FileasFile: java.io.FileFile) extends sbt.PathPath
{
	override def ()java.lang.StringtoString = java.lang.String(".")"."
	def => java.lang.StringrelativePath = java.lang.String("")""
	private[sbt] def (String)java.lang.StringprependTo(Strings: StringString) = java.lang.String(".")"." (Any)java.lang.String+ => Charsep (Any)java.lang.String+ Strings
}
private[sbt] final class class RelativePath extends sbt.Path with ScalaObjectRelativePath(val sbt.PathparentPath: sbt.PathPath, val Stringcomponent: StringString) extends sbt.PathPath
{
	(String)StringcheckComponent(=> Stringcomponent)
	override def ()StringtoString = => sbt.PathparentPath (String)StringprependTo => Stringcomponent
	lazy val java.io.FileasFile = (java.io.File,java.lang.String)java.io.Filenew java.io.FileFile(=> sbt.PathparentPath.=> java.io.FileasFile, => Stringcomponent)
	private[sbt] def (String)StringprependTo(Strings: StringString) =  => sbt.PathparentPath (String)StringprependTo (=> Stringcomponent (Any)java.lang.String+ => Charsep (Any)java.lang.String+ Strings)
	lazy val StringrelativePath =
	{
		val StringparentRelative = => sbt.PathparentPath.=> StringrelativePath
		Stringif(implicit scala.Predef.stringWrapper : (String)scala.runtime.RichStringparentRelative.=> BooleanisEmpty)
			=> Stringcomponent
		else
			StringparentRelative (Any)java.lang.String+ => Charsep (Any)java.lang.String+ => Stringcomponent
	}
}
object object sbt.PathPath
{
	import java.io.File
	import File.pathSeparator
	
	/** Constructs a String representation of <code>Path</code>s.  The absolute path String of each <code>Path</code> is
	* separated by the platform's path separator.*/
	def (Iterable[sbt.Path])StringmakeString(Iterable[sbt.Path]paths: Iterable[sbt.Path]Iterable[Path]): StringString = Iterable[sbt.Path]paths.((sbt.Path) => String)Iterable[String]map(sbt.Path_.=> StringabsolutePath).(String)StringmkString(java.lang.StringpathSeparator)
	
	/** Constructs a String representation of <code>Path</code>s.  The relative path String of each <code>Path</code> is
	* separated by the platform's path separator.*/
	def (Iterable[sbt.Path])StringmakeRelativeString(Iterable[sbt.Path]paths: Iterable[sbt.Path]Iterable[Path]): StringString = Iterable[sbt.Path]paths.((sbt.Path) => String)Iterable[String]map(sbt.Path_.=> StringrelativePath).(String)StringmkString(java.lang.StringpathSeparator)
	
	def (sbt.Path,String)Iterable[sbt.Path]splitString(sbt.PathprojectPath: sbt.PathPath, Stringvalue: StringString): Iterable[sbt.Path]Iterable[Path] =
	{
		for(((java.lang.String) => sbt.Path)Array[sbt.Path]pathString <- object sbt.FileUtilitiesFileUtilities.(String)Array[java.lang.String]pathSplit(Stringvalue) if java.lang.StringpathString.()Intlength (Int)Boolean> Int(0)0) yield
			object sbt.PathPath.(sbt.Path,String)sbt.PathfromString(sbt.PathprojectPath, java.lang.StringpathString)
	}
	
	/** A <code>PathFinder</code> that always produces the empty set of <code>Path</code>s.*/
	def => sbt.PathFinderemptyPathFinder =
		template $anon extends sbt.PathFindernew sbt.PathFinderPathFinder
		{
			private[sbt] def (scala.collection.mutable.Set[sbt.Path])UnitaddTo(scala.collection.mutable.Set[sbt.Path]pathSet: scala.collection.mutable.Set[sbt.Path]Set[Path]) Unit{}
		}
	/** A <code>PathFinder</code> that selects the paths provided by the <code>paths</code> argument, which is
	* reevaluated on each call to the <code>PathFinder</code>'s <code>get</code> method.  */
	def (=> Iterable[sbt.Path])sbt.PathFinderlazyPathFinder(=> Iterable[sbt.Path]paths: => Iterable[Path]): sbt.PathFinderPathFinder =
		template $anon extends sbt.PathFindernew sbt.PathFinderPathFinder
		{
			private[sbt] def (scala.collection.mutable.Set[sbt.Path])UnitaddTo(scala.collection.mutable.Set[sbt.Path]pathSet: scala.collection.mutable.Set[sbt.Path]Set[Path]) = scala.collection.mutable.Set[sbt.Path]pathSet (Iterable[sbt.Path])Unit++= => Iterable[sbt.Path]paths
		}
		
	/** The separator character of the platform.*/
	val Charsep = java.io.object java.io.FileFile.CharseparatorChar
	
	/** Checks the string to verify that it is a legal path component.  The string must be non-empty,
	* not a slash, and not '.' or '..'.*/
	def (String)StringcheckComponent(Stringc: StringString): StringString =
	{
		(Boolean,=> Any)Unitrequire(Stringc.()Intlength (Int)Boolean> Int(0)0, java.lang.String("Path component must not be empty")"Path component must not be empty")
		(Boolean,=> Any)Unitrequire(Stringc.(Int)IntindexOf(Int(47)'/') (Int)Boolean== -Int(-1)1, java.lang.String("Path component '")"Path component '" (Any)java.lang.String+ Stringc (Any)java.lang.String+ java.lang.String("' must not have forward slashes in it")"' must not have forward slashes in it")
		(Boolean,=> Any)Unitrequire(Stringc.(Int)IntindexOf(Int(92)'\\') (Int)Boolean== -Int(-1)1, java.lang.String("Path component '")"Path component '" (Any)java.lang.String+ Stringc (Any)java.lang.String+ java.lang.String("' must not have backslashes in it")"' must not have backslashes in it")
		(Boolean,=> Any)Unitrequire(Stringc (AnyRef)Boolean!= java.lang.String("..")"..", java.lang.String("Path component cannot be '..'")"Path component cannot be '..'")
		(Boolean,=> Any)Unitrequire(Stringc (AnyRef)Boolean!= java.lang.String(".")".", java.lang.String("Path component cannot be '.'")"Path component cannot be '.'")
		Stringc
	}
	/** Converts a path string relative to the given base path to a <code>Path</code>. */
	def (sbt.Path,String)sbt.PathfromString(sbt.PathbasePath: sbt.PathPath, Stringvalue: StringString): sbt.PathPath =
	{
		sbt.Pathif(implicit scala.Predef.stringWrapper : (String)scala.runtime.RichStringvalue.=> BooleanisEmpty)
			sbt.PathbasePath
		else
		{
			val Array[java.lang.String]components = Stringvalue.(java.lang.String)Array[java.lang.String]split(java.lang.String("[/\\]")"""[/\\]""")
			(sbt.PathbasePath (sbt.Path)((sbt.Path, java.lang.String) => sbt.Path)sbt.Path/: Array[java.lang.String]components)( (sbt.Pathpath, java.lang.Stringcomponent) => sbt.Pathpath (String)sbt.Path/ java.lang.Stringcomponent )
		}
	}
	def (sbt.Path)Option[sbt.Path]baseAncestor(sbt.Pathpath: sbt.PathPath): Option[sbt.Path]Option[Path] =
		sbt.Pathpath Option[sbt.Path]match
		{
			None.typecase sbt.ProjectDirectorypd: sbt.ProjectDirectoryProjectDirectory => object NoneNone
			Option[sbt.Path]case sbt.RelativePathrp: sbt.RelativePathRelativePath => (sbt.Path)Option[sbt.Path]baseAncestor(sbt.RelativePathrp.=> sbt.PathparentPath)
			Some[sbt.Path]case sbt.BaseDirectoryb: sbt.BaseDirectoryBaseDirectory => (sbt.Path)Some[sbt.Path]Some(sbt.BaseDirectoryb.=> sbt.Pathpath)
		}
	
	def (sbt.Path,sbt.Path)Option[sbt.Path]relativize(sbt.PathbasePath: sbt.PathPath, sbt.Pathpath: sbt.PathPath): Option[sbt.Path]Option[Path] = (sbt.Path,java.io.File)Option[sbt.Path]relativize(sbt.PathbasePath, sbt.Pathpath.=> java.io.FileasFile)
	def (sbt.Path,java.io.File)Option[sbt.Path]relativize(sbt.PathbasePath: sbt.PathPath, java.io.Filefile: java.io.FileFile): Option[sbt.Path]Option[Path] =
		(sbt.Path)Option[String]basePathString(sbt.PathbasePath) ((String) => Option[sbt.Path])Option[sbt.Path]flatMap { StringbaseString => (sbt.Path,String,java.io.File)Option[sbt.Path]relativize(sbt.PathbasePath, StringbaseString, java.io.Filefile) }
	def (sbt.Path,String,java.io.File)Option[sbt.Path]relativize(sbt.PathbasePath: sbt.PathPath, StringbasePathString: StringString, java.io.Filefile: java.io.FileFile): Option[sbt.Path]Option[Path] =
	{
		val java.lang.StringpathString = java.io.Filefile.()java.lang.StringgetCanonicalPath
		Option[sbt.Path]if(java.lang.StringpathString.(java.lang.String)BooleanstartsWith(StringbasePathString))
			(sbt.Path)Some[sbt.Path]Some((sbt.Path,String)sbt.PathfromString(sbt.PathbasePath, java.lang.StringpathString.(Int)java.lang.Stringsubstring(StringbasePathString.()Intlength)))
		else
			object NoneNone
	}
	private[sbt] def (java.io.File,java.io.File)Option[String]relativize(java.io.FilebaseFile: java.io.FileFile, java.io.Filefile: java.io.FileFile): Option[String]Option[String] =
	{
		val java.lang.StringpathString = java.io.Filefile.()java.lang.StringgetCanonicalPath
		(java.io.File)Option[String]baseFileString(java.io.FilebaseFile) ((String) => Option[String])Option[String]flatMap
		{
			StringbaseString =>
			{
				Option[String]if(java.lang.StringpathString.(java.lang.String)BooleanstartsWith(StringbaseString))
					(java.lang.String)Some[java.lang.String]Some(java.lang.StringpathString.(Int)java.lang.Stringsubstring(StringbaseString.()Intlength))
				else
					object NoneNone
			}
		}
	}
	private[sbt] def (sbt.Path)Option[String]basePathString(sbt.PathbasePath: sbt.PathPath): Option[String]Option[String] = (java.io.File)Option[String]baseFileString(sbt.PathbasePath.=> java.io.FileasFile)
	private def (java.io.File)Option[String]baseFileString(java.io.FilebaseFile: java.io.FileFile): Option[String]Option[String] =
	{
		Option[String]if(java.io.FilebaseFile.()BooleanisDirectory)
		{
			val java.lang.Stringcp = java.io.FilebaseFile.()java.lang.StringgetCanonicalPath
			(Boolean)Unitassert(java.lang.Stringcp.()Intlength (Int)Boolean> Int(0)0)
			Option[String]if(java.lang.Stringcp.(Int)CharcharAt(java.lang.Stringcp.()Intlength (Int)Int- Int(1)1) (Char)Boolean== object java.io.FileFile.CharseparatorChar)
				(java.lang.String)Some[java.lang.String]Some(java.lang.Stringcp)
			else
				(java.lang.String)Some[java.lang.String]Some(java.lang.Stringcp (Any)java.lang.String+ object java.io.FileFile.CharseparatorChar)
		}
		else
			object NoneNone
	}
	def (java.io.File)sbt.PathfromFile(java.io.Filefile: java.io.FileFile): sbt.PathPath = sbt.ProjectDirectorynew sbt.ProjectDirectoryProjectDirectory(java.io.Filefile)
}

/** A path finder constructs a set of paths.  The set is evaluated by a call to the <code>get</code>
* method.  The set will be different for different calls to <code>get</code> if the underlying filesystem
* has changed.*/
sealed abstract class class PathFinder extends java.lang.Object with NotNull with ScalaObjectPathFinder extends NotNullNotNull
{
	/** The union of the paths found by this <code>PathFinder</code> with the paths found by 'paths'.*/
	def (sbt.PathFinder)sbt.PathFinder+++(sbt.PathFinderpaths: sbt.PathFinderPathFinder): sbt.PathFinderPathFinder = sbt.Pathsnew sbt.PathsPaths(sbt.PathFinderthis, sbt.PathFinderpaths)
	/** Excludes all paths from <code>excludePaths</code> from the paths selected by this <code>PathFinder</code>.*/
	def (sbt.PathFinder)sbt.PathFinder---(sbt.PathFinderexcludePaths: sbt.PathFinderPathFinder): sbt.PathFinderPathFinder = sbt.ExcludePathsnew sbt.ExcludePathsExcludePaths(sbt.PathFinderthis, sbt.PathFinderexcludePaths)
	/** Constructs a new finder that selects all paths with a name that matches <code>filter</code> and are
	* descendents of paths selected by this finder.*/
	def (sbt.FileFilter)sbt.PathFinder**(sbt.FileFilterfilter: sbt.FileFilterFileFilter): sbt.PathFinderPathFinder = sbt.DescendentOrSelfPathFindernew sbt.DescendentOrSelfPathFinderDescendentOrSelfPathFinder(sbt.PathFinderthis, sbt.FileFilterfilter)
	/** Constructs a new finder that selects all paths with a name that matches <code>filter</code> and are
	* immediate children of paths selected by this finder.*/
	def (sbt.FileFilter)sbt.PathFinder*(sbt.FileFilterfilter: sbt.FileFilterFileFilter): sbt.PathFinderPathFinder = sbt.ChildPathFindernew sbt.ChildPathFinderChildPathFinder(sbt.PathFinderthis, sbt.FileFilterfilter)
	/** Constructs a new finder that selects all paths with name <code>literal</code> that are immediate children
	* of paths selected by this finder.*/
	def (String)sbt.PathFinder/ (Stringliteral: StringString): sbt.PathFinderPathFinder = sbt.ChildPathFindernew sbt.ChildPathFinderChildPathFinder(sbt.PathFinderthis, sbt.ExactFilternew sbt.ExactFilterExactFilter(Stringliteral))
	/** Constructs a new finder that selects all paths with name <code>literal</code> that are immediate children
	* of paths selected by this finder.*/
	final def (String)sbt.PathFinder\ (Stringliteral: StringString): sbt.PathFinderPathFinder = PathFinder.this.typethis (String)sbt.PathFinder/ Stringliteral

	/** Makes the paths selected by this finder into base directories.
	* @see Path.##
	*/
	def => sbt.PathFinder## : sbt.PathFinderPathFinder = sbt.BasePathFindernew sbt.BasePathFinderBasePathFinder(sbt.PathFinderthis)

	/** Selects all descendent paths with a name that matches <code>include</code> and do not have an intermediate
	* path with a name that matches <code>intermediateExclude</code>.  Typical usage is:
	*
	* <code>descendentsExcept("*.jar", ".svn")</code>*/
	def (sbt.FileFilter,sbt.FileFilter)sbt.PathFinderdescendentsExcept(sbt.FileFilterinclude: sbt.FileFilterFileFilter, sbt.FileFilterintermediateExclude: sbt.FileFilterFileFilter): sbt.PathFinderPathFinder =
		(PathFinder.this.typethis (sbt.FileFilter)sbt.PathFinder** sbt.FileFilterinclude) (sbt.PathFinder)sbt.PathFinder--- (PathFinder.this.typethis (sbt.FileFilter)sbt.PathFinder** sbt.FileFilterintermediateExclude (sbt.FileFilter)sbt.PathFinder** sbt.FileFilterinclude)
	
	/** Evaluates this finder.  The set returned by this method will reflect the underlying filesystem at the
	* time of calling.  If the filesystem changes, two calls to this method might be different.*/
	final def => scala.collection.Set[sbt.Path]get: scala.collection.scala.collection.Set[sbt.Path]Set[Path] =
	{
		val scala.collection.mutable.HashSet[sbt.Path]pathSet = scala.collection.mutable.HashSet[sbt.Path]new scala.collection.mutable.HashSet[sbt.Path]HashSet[Path]
		(scala.collection.mutable.Set[sbt.Path])UnitaddTo(scala.collection.mutable.HashSet[sbt.Path]pathSet)
		scala.collection.mutable.HashSet[sbt.Path]pathSet.=> scala.collection.Set[sbt.Path]readOnly
	}
	private[sbt] def (scala.collection.mutable.Set[sbt.Path])UnitaddTo(scala.collection.mutable.Set[sbt.Path]pathSet: scala.collection.mutable.Set[sbt.Path]Set[Path])
}
private class class BasePathFinder extends sbt.PathFinder with ScalaObjectBasePathFinder(sbt.PathFinderbase: sbt.PathFinderPathFinder) extends sbt.PathFinderPathFinder
{
	private[sbt] def (scala.collection.mutable.Set[sbt.Path])UnitaddTo(scala.collection.mutable.Set[sbt.Path]pathSet: scala.collection.mutable.Set[sbt.Path]Set[Path])
	{
		for(((sbt.Path) => Unit)Unitpath <- sbt.PathFinderbase.=> scala.collection.Set[sbt.Path]get)
			scala.collection.mutable.Set[sbt.Path]pathSet (sbt.Path)Unit+= (sbt.Pathpath => sbt.Path##)
	}
}
private abstract class class FilterPath extends sbt.PathFinder with sbt.FileFilter with ScalaObjectFilterPath extends sbt.PathFinderPathFinder with sbt.FileFilterFileFilter
{
	def => sbt.PathFinderparent: sbt.PathFinderPathFinder
	def => sbt.FileFilterfilter: sbt.FileFilterFileFilter
	final def (java.io.File)Booleanaccept(java.io.Filefile: java.io.FileFile) = => sbt.FileFilterfilter.(java.io.File)Booleanaccept(java.io.Filefile)
	
	protected def (sbt.Path,scala.collection.mutable.Set[sbt.Path])UnithandlePath(sbt.Pathpath: sbt.PathPath, scala.collection.mutable.Set[sbt.Path]pathSet: scala.collection.mutable.Set[sbt.Path]Set[Path])
	{
		for(((java.io.File) => Unit)UnitmatchedFile <- (Array[java.io.File])Array[java.io.File]wrapNull(sbt.Pathpath.=> java.io.FileasFile.(java.io.FileFilter)Array[java.io.File]listFiles(sbt.FilterPaththis)))
			scala.collection.mutable.Set[sbt.Path]pathSet (sbt.Path)Unit+= sbt.Pathpath (String)sbt.Path/ java.io.FilematchedFile.()java.lang.StringgetName
	}
}
private class class DescendentOrSelfPathFinder extends sbt.FilterPath with ScalaObjectDescendentOrSelfPathFinder(val sbt.PathFinderparent: sbt.PathFinderPathFinder, val sbt.FileFilterfilter: sbt.FileFilterFileFilter) extends sbt.FilterPathFilterPath
{
	private[sbt] def (scala.collection.mutable.Set[sbt.Path])UnitaddTo(scala.collection.mutable.Set[sbt.Path]pathSet: scala.collection.mutable.Set[sbt.Path]Set[Path])
	{
		for(((sbt.Path) => Unit)Unitpath <- => sbt.PathFinderparent.=> scala.collection.Set[sbt.Path]get)
		{
			Unitif((java.io.File)Booleanaccept(sbt.Pathpath.=> java.io.FileasFile))
				scala.collection.mutable.Set[sbt.Path]pathSet (sbt.Path)Unit+= sbt.Pathpath
			(sbt.Path,scala.collection.mutable.Set[sbt.Path])UnithandlePathDescendent(sbt.Pathpath, scala.collection.mutable.Set[sbt.Path]pathSet)
		}
	}
	private def (sbt.Path,scala.collection.mutable.Set[sbt.Path])UnithandlePathDescendent(sbt.Pathpath: sbt.PathPath, scala.collection.mutable.Set[sbt.Path]pathSet: scala.collection.mutable.Set[sbt.Path]Set[Path])
	{
		(sbt.Path,scala.collection.mutable.Set[sbt.Path])UnithandlePath(sbt.Pathpath, scala.collection.mutable.Set[sbt.Path]pathSet)
		for(((java.io.File) => Unit)UnitchildDirectory <- (Array[java.io.File])Array[java.io.File]wrapNull(sbt.Pathpath.=> java.io.FileasFile.(java.io.FileFilter)Array[java.io.File]listFiles(object sbt.DirectoryFilterDirectoryFilter)))
			(sbt.Path,scala.collection.mutable.Set[sbt.Path])UnithandlePathDescendent(sbt.Pathpath (String)sbt.Path/ java.io.FilechildDirectory.()java.lang.StringgetName, scala.collection.mutable.Set[sbt.Path]pathSet)
	}
}
private class class ChildPathFinder extends sbt.FilterPath with ScalaObjectChildPathFinder(val sbt.PathFinderparent: sbt.PathFinderPathFinder, val sbt.FileFilterfilter: sbt.FileFilterFileFilter) extends sbt.FilterPathFilterPath
{
	private[sbt] def (scala.collection.mutable.Set[sbt.Path])UnitaddTo(scala.collection.mutable.Set[sbt.Path]pathSet: scala.collection.mutable.Set[sbt.Path]Set[Path])
	{
		for(((sbt.Path) => Unit)Unitpath <- => sbt.PathFinderparent.=> scala.collection.Set[sbt.Path]get)
			(sbt.Path,scala.collection.mutable.Set[sbt.Path])UnithandlePath(sbt.Pathpath, scala.collection.mutable.Set[sbt.Path]pathSet)
	}
}
private class class Paths extends sbt.PathFinder with ScalaObjectPaths(sbt.PathFindera: sbt.PathFinderPathFinder, sbt.PathFinderb: sbt.PathFinderPathFinder) extends sbt.PathFinderPathFinder
{
	private[sbt] def (scala.collection.mutable.Set[sbt.Path])UnitaddTo(scala.collection.mutable.Set[sbt.Path]pathSet: scala.collection.mutable.Set[sbt.Path]Set[Path])
	{
		sbt.PathFindera.(scala.collection.mutable.Set[sbt.Path])UnitaddTo(scala.collection.mutable.Set[sbt.Path]pathSet)
		sbt.PathFinderb.(scala.collection.mutable.Set[sbt.Path])UnitaddTo(scala.collection.mutable.Set[sbt.Path]pathSet)
	}
}
private class class ExcludePaths extends sbt.PathFinder with ScalaObjectExcludePaths(sbt.PathFinderinclude: sbt.PathFinderPathFinder, sbt.PathFinderexclude: sbt.PathFinderPathFinder) extends sbt.PathFinderPathFinder
{
	private[sbt] def (scala.collection.mutable.Set[sbt.Path])UnitaddTo(scala.collection.mutable.Set[sbt.Path]pathSet: scala.collection.mutable.Set[sbt.Path]Set[Path])
	{
		val scala.collection.mutable.HashSet[sbt.Path]includeSet = scala.collection.mutable.HashSet[sbt.Path]new scala.collection.mutable.HashSet[sbt.Path]HashSet[Path]
		sbt.PathFinderinclude.(scala.collection.mutable.Set[sbt.Path])UnitaddTo(scala.collection.mutable.HashSet[sbt.Path]includeSet)
		
		val scala.collection.mutable.HashSet[sbt.Path]excludeSet = scala.collection.mutable.HashSet[sbt.Path]new scala.collection.mutable.HashSet[sbt.Path]HashSet[Path]
		sbt.PathFinderexclude.(scala.collection.mutable.Set[sbt.Path])UnitaddTo(scala.collection.mutable.HashSet[sbt.Path]excludeSet)
		
		scala.collection.mutable.HashSet[sbt.Path]includeSet (Iterable[sbt.Path])Unit--= scala.collection.mutable.HashSet[sbt.Path]excludeSet
		scala.collection.mutable.Set[sbt.Path]pathSet (Iterable[sbt.Path])Unit++= scala.collection.mutable.HashSet[sbt.Path]includeSet
	}
}