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

import java.io.File
import java.net.URL
import java.util.Collections
import scala.collection.mutable.HashSet

import org.apache.ivy.{core, plugins, util, Ivy}
import core.LogOptions
import core.deliver.DeliverOptions
import core.module.descriptor.{DefaultArtifact, DefaultDependencyDescriptor, DefaultModuleDescriptor, MDArtifact, ModuleDescriptor}
import core.module.descriptor.{DefaultExcludeRule, ExcludeRule}
import core.module.id.{ArtifactId,ModuleId, ModuleRevisionId}
import core.publish.PublishOptions
import core.resolve.ResolveOptions
import core.retrieve.RetrieveOptions
import core.settings.IvySettings
import plugins.matcher.{ExactPatternMatcher, PatternMatcher}
import plugins.parser.ModuleDescriptorParser
import plugins.parser.m2.{PomModuleDescriptorParser,PomModuleDescriptorWriter}
import plugins.parser.xml.XmlModuleDescriptorParser
import plugins.repository.{BasicResource, Resource}
import plugins.repository.url.URLResource
import plugins.resolver.{DependencyResolver, ChainResolver, IBiblioResolver}
import util.{Message, MessageLogger}

final class class IvyScala extends java.lang.Object with NotNull with ScalaObjectIvyScala(val StringscalaVersion: StringString, val Iterable[sbt.Configuration]configurations: Iterable[sbt.Configuration]Iterable[Configuration], val BooleancheckExplicit: BooleanBoolean, val BooleanfilterImplicit: BooleanBoolean) extends NotNullNotNull
final class class IvyPaths extends java.lang.Object with NotNull with ScalaObjectIvyPaths(val sbt.PathprojectDirectory: sbt.PathPath, val sbt.PathmanagedLibDirectory: sbt.PathPath, val Option[sbt.Path]cacheDirectory: Option[sbt.Path]Option[Path]) extends NotNullNotNull
final class class IvyFlags extends java.lang.Object with NotNull with ScalaObjectIvyFlags(val Booleanvalidate: BooleanBoolean, val BooleanaddScalaTools: BooleanBoolean, val BooleanerrorIfNoConfiguration: BooleanBoolean) extends NotNullNotNull
final class class IvyConfiguration extends java.lang.Object with NotNull with ScalaObjectIvyConfiguration(val sbt.IvyPathspaths: sbt.IvyPathsIvyPaths, val sbt.Managermanager: sbt.ManagerManager, val sbt.IvyFlagsflags: sbt.IvyFlagsIvyFlags, val Option[sbt.IvyScala]ivyScala: Option[sbt.IvyScala]Option[IvyScala], val sbt.Loggerlog: sbt.LoggerLogger) extends NotNullNotNull
final class class UpdateConfiguration extends java.lang.Object with NotNull with ScalaObjectUpdateConfiguration(val StringoutputPattern: StringString, val Booleansynchronize: BooleanBoolean, val Booleanquiet: BooleanBoolean) extends NotNullNotNull
object object sbt.ManageDependenciesManageDependencies
{
	val java.lang.StringDefaultIvyConfigFilename = java.lang.String("ivysettings.xml")"ivysettings.xml"
	val java.lang.StringDefaultIvyFilename = java.lang.String("ivy.xml")"ivy.xml"
	val java.lang.StringDefaultMavenFilename = java.lang.String("pom.xml")"pom.xml"
	val java.lang.StringScalaOrganization = java.lang.String("org.scala-lang")"org.scala-lang"
	val java.lang.StringScalaLibraryID = java.lang.String("scala-library")"scala-library"
	val java.lang.StringScalaCompilerID = java.lang.String("scala-compiler")"scala-compiler"
	
	private def (sbt.Path)sbt.PathdefaultIvyFile(sbt.Pathproject: sbt.PathPath) = sbt.Pathproject (String)sbt.Path/ => java.lang.StringDefaultIvyFilename
	private def (sbt.Path)sbt.PathdefaultIvyConfiguration(sbt.Pathproject: sbt.PathPath) = sbt.Pathproject (String)sbt.Path/ => java.lang.StringDefaultIvyConfigFilename
	private def (sbt.Path)sbt.PathdefaultPOM(sbt.Pathproject: sbt.PathPath) = sbt.Pathproject (String)sbt.Path/ => java.lang.StringDefaultMavenFilename
	
	/** Configures Ivy using the provided configuration 'config' and calls 'doWithIvy'.  This method takes care of setting up and cleaning up Ivy.*/
	private def (sbt.IvyConfiguration)((org.apache.ivy.Ivy, org.apache.ivy.core.module.descriptor.ModuleDescriptor, String) => Option[String])Option[String]withIvy(sbt.IvyConfigurationconfig: sbt.IvyConfigurationIvyConfiguration)((org.apache.ivy.Ivy, org.apache.ivy.core.module.descriptor.ModuleDescriptor, String) => Option[String]doWithIvy: (Ivy, ModuleDescriptor, String) => Option[String]) =
		(sbt.IvyConfiguration)((org.apache.ivy.Ivy, org.apache.ivy.core.module.descriptor.ModuleDescriptor, String) => Either[String,Unit])Either[String,Unit]withIvyValue(sbt.IvyConfigurationconfig)( (org.apache.ivy.Ivyivy, org.apache.ivy.core.module.descriptor.ModuleDescriptormodule, Stringdefault) => (org.apache.ivy.Ivy,org.apache.ivy.core.module.descriptor.ModuleDescriptor,String)Option[String]doWithIvy(org.apache.ivy.Ivyivy, org.apache.ivy.core.module.descriptor.ModuleDescriptormodule, Stringdefault).(=> Unit)Either[String,Unit] with ProducttoLeft(Unit()) ).=> Either.LeftProjection[String,Unit]left.=> Option[String]toOption
	/** Configures Ivy using the provided configuration 'config' and calls 'doWithIvy'.  This method takes care of setting up and cleaning up Ivy.*/
	private def [T](sbt.IvyConfiguration)((org.apache.ivy.Ivy, org.apache.ivy.core.module.descriptor.ModuleDescriptor, String) => Either[String,T])Either[String,T]withIvyValue[>: Nothing <: AnyT](sbt.IvyConfigurationconfig: sbt.IvyConfigurationIvyConfiguration)((org.apache.ivy.Ivy, org.apache.ivy.core.module.descriptor.ModuleDescriptor, String) => Either[String,T]doWithIvy: (Ivy, ModuleDescriptor, String) => Either[String, T]) =
	{
		import config._
		val sbt.IvyLoggerlogger = sbt.IvyLoggernew sbt.IvyLoggerIvyLogger(=> sbt.Loggerlog)
		object org.apache.ivy.util.MessageMessage.(org.apache.ivy.util.MessageLogger)UnitsetDefaultLogger(sbt.IvyLoggerlogger)
		val org.apache.ivy.Ivyivy = object org.apache.ivy.IvyIvy.()org.apache.ivy.IvynewInstance()
		org.apache.ivy.Ivyivy.()org.apache.ivy.util.MessageLoggerEnginegetLoggerEngine.(org.apache.ivy.util.MessageLogger)UnitpushLogger(sbt.IvyLoggerlogger)
		
		/** Parses the given Maven pom 'pomFile'.*/
		def (java.io.File)Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, java.lang.String)]readPom(java.io.FilepomFile: java.io.FileFile) =
			object sbt.ControlControl.(=> String,sbt.Logger)(=> Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, java.lang.String)])Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, java.lang.String)]trap(java.lang.String("Could not read pom: ")"Could not read pom: ", => sbt.Loggerlog)
				{ ((org.apache.ivy.core.module.descriptor.ModuleDescriptor, java.lang.String))Right[Nothing,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, java.lang.String)]Right((object org.apache.ivy.plugins.parser.m2.PomModuleDescriptorParserPomModuleDescriptorParser.()org.apache.ivy.plugins.parser.m2.PomModuleDescriptorParsergetInstance.(org.apache.ivy.plugins.parser.ParserSettings,java.net.URL,Boolean)org.apache.ivy.core.module.descriptor.ModuleDescriptorparseDescriptor(org.apache.ivy.Ivyivy.()org.apache.ivy.core.settings.IvySettingsgetSettings, (java.io.File)java.net.URLtoURL(java.io.FilepomFile), => sbt.IvyFlagsflags.=> Booleanvalidate)), java.lang.String("compile")"compile") }
		/** Parses the given Ivy file 'ivyFile'.*/
		def (java.io.File)Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, java.lang.String)]readIvyFile(java.io.FileivyFile: java.io.FileFile) =
			object sbt.ControlControl.(=> String,sbt.Logger)(=> Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, java.lang.String)])Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, java.lang.String)]trap(java.lang.String("Could not read Ivy file: ")"Could not read Ivy file: ", => sbt.Loggerlog)
			{
				val java.net.URLurl = (java.io.File)java.net.URLtoURL(java.io.FileivyFile)
				val sbt.ManageDependencies.CustomXmlParser.CustomParserparser = sbt.ManageDependencies.CustomXmlParser.CustomParsernew object sbt.ManageDependencies.CustomXmlParserCustomXmlParser.sbt.ManageDependencies.CustomXmlParser.CustomParserCustomParser(org.apache.ivy.Ivyivy.()org.apache.ivy.core.settings.IvySettingsgetSettings)
				sbt.ManageDependencies.CustomXmlParser.CustomParserparser.(Boolean)UnitsetValidate(=> sbt.IvyFlagsflags.=> Booleanvalidate)
				sbt.ManageDependencies.CustomXmlParser.CustomParserparser.(java.net.URL)UnitsetSource(java.net.URLurl)
				sbt.ManageDependencies.CustomXmlParser.CustomParserparser.()Unitparse()
				((org.apache.ivy.core.module.descriptor.ModuleDescriptor, java.lang.String))Right[Nothing,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, java.lang.String)]Right((org.apache.ivy.core.module.descriptor.ModuleDescriptor,java.lang.String)(org.apache.ivy.core.module.descriptor.ModuleDescriptor, java.lang.String)(sbt.ManageDependencies.CustomXmlParser.CustomParserparser.()org.apache.ivy.core.module.descriptor.ModuleDescriptorgetModuleDescriptor(), sbt.ManageDependencies.CustomXmlParser.CustomParserparser.()java.lang.StringgetDefaultConf))
			}
		/** Parses the given in-memory Ivy file 'xml', using the existing 'moduleID' and specifying the given 'defaultConfiguration'. */
		def (scala.xml.NodeSeq,org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor,String)Either[String,sbt.ManageDependencies.CustomXmlParser.CustomParser]parseXMLDependencies(scala.xml.NodeSeqxml: scala.xml.scala.xml.NodeSeqNodeSeq, org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormoduleID: org.apache.ivy.core.module.descriptor.DefaultModuleDescriptorDefaultModuleDescriptor, StringdefaultConfiguration: StringString) =
			(String,org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor,String)Either[String,sbt.ManageDependencies.CustomXmlParser.CustomParser]parseDependencies(scala.xml.NodeSeqxml.()StringtoString, org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormoduleID, StringdefaultConfiguration)
		/** Parses the given in-memory Ivy file 'xml', using the existing 'moduleID' and specifying the given 'defaultConfiguration'. */
		def (String,org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor,String)Either[String,sbt.ManageDependencies.CustomXmlParser.CustomParser]parseDependencies(Stringxml: StringString, org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormoduleID: org.apache.ivy.core.module.descriptor.DefaultModuleDescriptorDefaultModuleDescriptor, StringdefaultConfiguration: StringString): Either[String,sbt.ManageDependencies.CustomXmlParser.CustomParser]Either[String, CustomXmlParser.CustomParser] =
			object sbt.ControlControl.(=> String,sbt.Logger)(=> Either[String,sbt.ManageDependencies.CustomXmlParser.CustomParser])Either[String,sbt.ManageDependencies.CustomXmlParser.CustomParser]trap(java.lang.String("Could not read dependencies: ")"Could not read dependencies: ", => sbt.Loggerlog)
			{
				val sbt.ManageDependencies.CustomXmlParser.CustomParserparser = sbt.ManageDependencies.CustomXmlParser.CustomParsernew object sbt.ManageDependencies.CustomXmlParserCustomXmlParser.sbt.ManageDependencies.CustomXmlParser.CustomParserCustomParser(org.apache.ivy.Ivyivy.()org.apache.ivy.core.settings.IvySettingsgetSettings)
				sbt.ManageDependencies.CustomXmlParser.CustomParserparser.(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor)UnitsetMd(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormoduleID)
				sbt.ManageDependencies.CustomXmlParser.CustomParserparser.(String)UnitsetDefaultConf(StringdefaultConfiguration)
				sbt.ManageDependencies.CustomXmlParser.CustomParserparser.(Boolean)UnitsetValidate(=> sbt.IvyFlagsflags.=> Booleanvalidate)
				val sbt.ManageDependencies.ByteResourceresource = sbt.ManageDependencies.ByteResourcenew sbt.ManageDependencies.ByteResourceByteResource(Stringxml.()Array[Byte]getBytes)
				sbt.ManageDependencies.CustomXmlParser.CustomParserparser.(java.io.InputStream)UnitsetInput(sbt.ManageDependencies.ByteResourceresource.()java.io.ByteArrayInputStreamopenStream)
				sbt.ManageDependencies.CustomXmlParser.CustomParserparser.(org.apache.ivy.plugins.repository.Resource)UnitsetResource(sbt.ManageDependencies.ByteResourceresource)
				sbt.ManageDependencies.CustomXmlParser.CustomParserparser.()Unitparse()
				(sbt.ManageDependencies.CustomXmlParser.CustomParser)Right[Nothing,sbt.ManageDependencies.CustomXmlParser.CustomParser]Right(sbt.ManageDependencies.CustomXmlParser.CustomParserparser)
			}
		/** Configures Ivy using the specified Ivy configuration file.  This method is used when the manager is explicitly requested to be MavenManager or
		* IvyManager.  If a file is not specified, Ivy is configured with defaults and scala-tools releases is added as a repository.*/
		def (Option[sbt.Path])Unitconfigure(Option[sbt.Path]configFile: Option[sbt.Path]Option[Path])
		{
			Option[sbt.Path]configFile Unitmatch
			{
				Unitcase Some(sbt.Pathpath) => org.apache.ivy.Ivyivy.(java.io.File)Unitconfigure(sbt.Pathpath.=> java.io.FileasFile)
				Unitcase object NoneNone =>
					()UnitconfigureDefaults()
					()UnitscalaTools()
			}
		}
		/** Adds the scala-tools.org releases maven repository to the list of resolvers if configured to do so in IvyFlags.*/
		def ()UnitscalaTools()
		{
			Unitif(=> sbt.IvyFlagsflags.=> BooleanaddScalaTools)
			{
				=> sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Added Scala Tools Releases repository.")"Added Scala Tools Releases repository.")
				(org.apache.ivy.core.settings.IvySettings,Iterable[sbt.Resolver],sbt.Logger)UnitaddResolvers(org.apache.ivy.Ivyivy.()org.apache.ivy.core.settings.IvySettingsgetSettings, object sbt.ScalaToolsReleasesScalaToolsReleases (object sbt.ScalaToolsReleases)List[object sbt.ScalaToolsReleases]:: object NilNil, => sbt.Loggerlog)
			}
		}
		/** Configures Ivy using defaults.  This is done when no ivy-settings.xml exists and no inline configurations or resolvers are specified. */
		def ()UnitconfigureDefaults()
		{
			org.apache.ivy.Ivyivy.()UnitconfigureDefault
			val org.apache.ivy.core.settings.IvySettingssettings = org.apache.ivy.Ivyivy.()org.apache.ivy.core.settings.IvySettingsgetSettings
			for(((sbt.Path) => Unit)Unitdir <- => sbt.IvyPathspaths.=> Option[sbt.Path]cacheDirectory) org.apache.ivy.core.settings.IvySettingssettings.(java.io.File)UnitsetDefaultCache(sbt.Pathdir.=> java.io.FileasFile)
			org.apache.ivy.core.settings.IvySettingssettings.(java.io.File)UnitsetBaseDir(=> sbt.IvyPathspaths.=> sbt.PathprojectDirectory.=> java.io.FileasFile)
		}
		/** Called to configure Ivy when the configured dependency manager is SbtManager and inline configuration is specified or if the manager
		* is AutodetectManager.  It will configure Ivy with an 'ivy-settings.xml' file if there is one, or configure the defaults and add scala-tools as
		* a repository otherwise.*/
		def ()UnitautodetectConfiguration()
		{
			=> sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Autodetecting configuration.")"Autodetecting configuration.")
			val java.io.FiledefaultIvyConfigFile = (sbt.Path)sbt.PathdefaultIvyConfiguration(=> sbt.IvyPathspaths.=> sbt.PathprojectDirectory).=> java.io.FileasFile
			Unitif(java.io.FiledefaultIvyConfigFile.()BooleancanRead)
				org.apache.ivy.Ivyivy.(java.io.File)Unitconfigure(java.io.FiledefaultIvyConfigFile)
			else
			{
				()UnitconfigureDefaults()
				()UnitscalaTools()
			}
		}
		/** Called to determine dependencies when the dependency manager is SbtManager and no inline dependencies (Scala or XML) are defined
		* or if the manager is AutodetectManager.  It will try to read from pom.xml first and then ivy.xml if pom.xml is not found.  If neither is found,
		* Ivy is configured with defaults unless IvyFlags.errorIfNoConfiguration is true, in which case an error is generated.*/
		def (org.apache.ivy.core.module.id.ModuleRevisionId)Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, java.lang.String)]autodetectDependencies(org.apache.ivy.core.module.id.ModuleRevisionIdmodule: org.apache.ivy.core.module.id.ModuleRevisionIdModuleRevisionId) =
		{
			=> sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Autodetecting dependencies.")"Autodetecting dependencies.")
			val java.io.FiledefaultPOMFile = (sbt.Path)sbt.PathdefaultPOM(=> sbt.IvyPathspaths.=> sbt.PathprojectDirectory).=> java.io.FileasFile
			Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, java.lang.String)]if(java.io.FiledefaultPOMFile.()BooleancanRead)
				(java.io.File)Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, java.lang.String)]readPom(java.io.FiledefaultPOMFile)
			else
			{
				val java.io.FiledefaultIvy = (sbt.Path)sbt.PathdefaultIvyFile(=> sbt.IvyPathspaths.=> sbt.PathprojectDirectory).=> java.io.FileasFile
				Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, java.lang.String)]if(java.io.FiledefaultIvy.()BooleancanRead)
					(java.io.File)Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, java.lang.String)]readIvyFile(java.io.FiledefaultIvy)
				else <refinement> extends Either[java.lang.String,(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor, java.lang.String)] with Productif(=> sbt.IvyFlagsflags.=> BooleanerrorIfNoConfiguration)
					(java.lang.String)Left[java.lang.String,Nothing]Left(java.lang.String("No readable dependency configuration found.  Need ")"No readable dependency configuration found.  Need " (Any)java.lang.String+ => java.lang.StringDefaultIvyFilename (Any)java.lang.String+ java.lang.String(" or ")" or " (Any)java.lang.String+ => java.lang.StringDefaultMavenFilename)
				else
				{
					val java.lang.StringdefaultConf = ModuleDescriptor.java.lang.String("default")DEFAULT_CONFIGURATION
					=> sbt.Loggerlog.(=> String)Unitwarn(java.lang.String("No readable dependency configuration found, using defaults.")"No readable dependency configuration found, using defaults.")
					val org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormoduleID = object org.apache.ivy.core.module.descriptor.DefaultModuleDescriptorDefaultModuleDescriptor.(org.apache.ivy.core.module.id.ModuleRevisionId)org.apache.ivy.core.module.descriptor.DefaultModuleDescriptornewDefaultInstance(org.apache.ivy.core.module.id.ModuleRevisionIdmodule)
					(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor)UnitaddMainArtifact(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormoduleID)
					(String,org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor)UnitaddDefaultArtifact(java.lang.StringdefaultConf, org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormoduleID)
					((org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor, java.lang.String))Right[Nothing,(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor, java.lang.String)]Right((org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor,java.lang.String)(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor, java.lang.String)(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormoduleID, java.lang.StringdefaultConf))
				}
			}
		}
		/** Creates an Ivy module descriptor according the manager configured.  The default configuration for dependencies
		* is also returned.*/
		def => Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)]moduleDescriptor: Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)]Either[String, (ModuleDescriptor, String)] =
			sbt.IvyConfigurationconfig.=> sbt.Managermanager Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)]match
			{
				Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, java.lang.String)]case sbt.MavenManagermm: sbt.MavenManagerMavenManager =>
				{
					=> sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Maven configuration explicitly requested.")"Maven configuration explicitly requested.")
					(Option[sbt.Path])Unitconfigure(sbt.MavenManagermm.=> Option[sbt.Path]configuration)
					(java.io.File)Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, java.lang.String)]readPom(sbt.MavenManagermm.=> sbt.Pathpom.=> java.io.FileasFile)
				}
				Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, java.lang.String)]case sbt.IvyManagerim: sbt.IvyManagerIvyManager =>
				{
					=> sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Ivy configuration explicitly requested.")"Ivy configuration explicitly requested.")
					(Option[sbt.Path])Unitconfigure(sbt.IvyManagerim.=> Option[sbt.Path]configuration)
					(java.io.File)Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, java.lang.String)]readIvyFile(sbt.IvyManagerim.=> sbt.Pathdependencies.=> java.io.FileasFile)
				}
				Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, java.lang.String)]case sbt.AutoDetectManageradm: sbt.AutoDetectManagerAutoDetectManager =>
				{
					=> sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("No dependency manager explicitly specified.")"No dependency manager explicitly specified.")
					()UnitautodetectConfiguration()
					(org.apache.ivy.core.module.id.ModuleRevisionId)Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, java.lang.String)]autodetectDependencies((sbt.ModuleID)org.apache.ivy.core.module.id.ModuleRevisionIdtoID(sbt.AutoDetectManageradm.=> sbt.ModuleIDmodule))
				}
				Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)]case sbt.SbtManagersm: sbt.SbtManagerSbtManager =>
				{
					import sm._
					Unitif(=> Iterable[sbt.Resolver]resolvers.=> BooleanisEmpty (Boolean)Boolean&& => BooleanautodetectUnspecified)
						()UnitautodetectConfiguration()
					else
					{
						=> sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Using inline configuration.")"Using inline configuration.")
						()UnitconfigureDefaults()
						val Iterable[sbt.Resolver]extra = Iterable[sbt.Resolver]if(=> sbt.IvyFlagsflags.=> BooleanaddScalaTools) object sbt.ScalaToolsReleasesScalaToolsReleases (sbt.Resolver)List[sbt.Resolver]:: => Iterable[sbt.Resolver]resolvers.=> List[sbt.Resolver]toList else => Iterable[sbt.Resolver]resolvers
						(org.apache.ivy.core.settings.IvySettings,Iterable[sbt.Resolver],sbt.Logger)UnitaddResolvers(org.apache.ivy.Ivyivy.()org.apache.ivy.core.settings.IvySettingsgetSettings, Iterable[sbt.Resolver]extra, => sbt.Loggerlog)
					}
					Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)]if(=> Iterable[sbt.ModuleID]dependencies.=> BooleanisEmpty (Boolean)Boolean&& => scala.xml.NodeSeqdependenciesXML.=> BooleanisEmpty (Boolean)Boolean&& => BooleanautodetectUnspecified)
						(org.apache.ivy.core.module.id.ModuleRevisionId)Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, java.lang.String)]autodetectDependencies((sbt.ModuleID)org.apache.ivy.core.module.id.ModuleRevisionIdtoID(=> sbt.ModuleIDmodule))
					else
					{
						val org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormoduleID =
							{
								val org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormod = (org.apache.ivy.core.module.id.ModuleRevisionId,java.lang.String,java.util.Date,Boolean)org.apache.ivy.core.module.descriptor.DefaultModuleDescriptornew org.apache.ivy.core.module.descriptor.DefaultModuleDescriptorDefaultModuleDescriptor((sbt.ModuleID)org.apache.ivy.core.module.id.ModuleRevisionIdtoID(=> sbt.ModuleIDmodule), java.lang.String("release")"release", Null(null)null, Boolean(false)false)
								org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormod.(Long)UnitsetLastModified(object java.lang.SystemSystem.()LongcurrentTimeMillis)
								=> Iterable[sbt.Configuration]configurations.((sbt.Configuration) => Unit)Unitforeach(sbt.Configurationconfig => org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormod.(org.apache.ivy.core.module.descriptor.Configuration)UnitaddConfiguration(sbt.Configurationconfig.=> org.apache.ivy.core.module.descriptor.ConfigurationtoIvyConfiguration))
								org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormod
							}
						val sbt.ConfigurationdefaultConf = => Option[sbt.Configuration]defaultConfiguration (=> sbt.Configuration)sbt.ConfigurationgetOrElse object sbt.ConfigurationsConfigurations.(String)sbt.Configurationconfig(ModuleDescriptor.java.lang.String("default")DEFAULT_CONFIGURATION)
						=> sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Using inline dependencies specified in Scala")"Using inline dependencies specified in Scala" (Any)java.lang.String+ (Anyif(=> scala.xml.NodeSeqdependenciesXML.=> BooleanisEmpty) java.lang.String(".")"." else java.lang.String(" and XML.")" and XML."))
						for(((sbt.ManageDependencies.CustomXmlParser.CustomParser) => (org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor, java.lang.String))Either[String,(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor, java.lang.String)] with Productparser <- (scala.xml.NodeSeq,org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor,String)Either[String,sbt.ManageDependencies.CustomXmlParser.CustomParser]parseXMLDependencies((sbt.ModuleID,scala.xml.NodeSeq)scala.xml.Elemwrapped(=> sbt.ModuleIDmodule, => scala.xml.NodeSeqdependenciesXML), org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormoduleID, sbt.ConfigurationdefaultConf.=> Stringname).=> Either.RightProjection[String,sbt.ManageDependencies.CustomXmlParser.CustomParser]right) yield
						{
							(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor,Iterable[sbt.ModuleID],sbt.ManageDependencies.CustomXmlParser.CustomParser)UnitaddDependencies(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormoduleID, => Iterable[sbt.ModuleID]dependencies, sbt.ManageDependencies.CustomXmlParser.CustomParserparser)
							(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor)UnitaddMainArtifact(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormoduleID)
							(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor,java.lang.String)(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor, java.lang.String)(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormoduleID, sbt.ManageDependencies.CustomXmlParser.CustomParserparser.()java.lang.StringgetDefaultConf)
						}
					}
				}
			}
		/** Creates a full ivy file for 'module' using the 'dependencies' XML as the part after the %lt;info&gt;...%lt;/info&gt; section. */
		def (sbt.ModuleID,scala.xml.NodeSeq)scala.xml.Elemwrapped(sbt.ModuleIDmodule: sbt.ModuleIDModuleID, scala.xml.NodeSeqdependencies: scala.xml.scala.xml.NodeSeqNodeSeq) =
		{
			import module._
			<ivy-module version=scala.xml.Text"2.0">
				<info organisation={=> Stringorganization} module={=> Stringname} revision={=> Stringrevision}/>
				{scala.xml.NodeSeqdependencies}
			</ivy-module>
		}
		/** Performs checks/adds filters on Scala dependencies (if enabled in IvyScala). */
		def ((org.apache.ivy.core.module.descriptor.ModuleDescriptor, String))Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)]checkModule((org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)moduleAndConf: (org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)(ModuleDescriptor, String)): Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)]Either[String, (ModuleDescriptor, String)] =
			=> Option[sbt.IvyScala]ivyScala Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)]match
			{
				Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)]case Some(sbt.IvyScalacheck) =>
					val (org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)(org.apache.ivy.core.module.descriptor.ModuleDescriptormodule, Stringconf) = (org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)moduleAndConf
					val Option[String]explicitCheck =
						Option[String]if(sbt.IvyScalacheck.=> BooleancheckExplicit)
							(org.apache.ivy.core.module.descriptor.ModuleDescriptor,String,Iterable[sbt.Configuration])Option[String]checkDependencies(org.apache.ivy.core.module.descriptor.ModuleDescriptormodule, sbt.IvyScalacheck.=> StringscalaVersion, sbt.IvyScalacheck.=> Iterable[sbt.Configuration]configurations)
						else
							object NoneNone
					Option[String]explicitCheck Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)]match
					{
						Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)]case object NoneNone =>
							Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)]if(sbt.IvyScalacheck.=> BooleanfilterImplicit)
							{
								val org.apache.ivy.core.module.descriptor.DefaultModuleDescriptorasDefault = (org.apache.ivy.core.module.descriptor.ModuleDescriptor)org.apache.ivy.core.module.descriptor.DefaultModuleDescriptortoDefaultModuleDescriptor(org.apache.ivy.core.module.descriptor.ModuleDescriptormodule)
								(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor,Iterable[sbt.Configuration])UnitexcludeScalaJars(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptorasDefault, sbt.IvyScalacheck.=> Iterable[sbt.Configuration]configurations)
								((org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor, String))Right[Nothing,(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor, String)]Right( (org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor,String)(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor, String)(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptorasDefault, Stringconf) )
							}
							else
								((org.apache.ivy.core.module.descriptor.ModuleDescriptor, String))Right[Nothing,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)]Right((org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)moduleAndConf)
						Left[String,Nothing]case Some(Stringerr) => (String)Left[String,Nothing]Left(Stringerr)
					}
				Right[Nothing,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)]case object NoneNone => ((org.apache.ivy.core.module.descriptor.ModuleDescriptor, String))Right[Nothing,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)]Right((org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)moduleAndConf)
			}
		
		this.(Either[String,T])Either[String,T]synchronized // Ivy is not thread-safe.  In particular, it uses a static DocumentBuilder, which is not thread-safe
		{
			org.apache.ivy.Ivyivy.()UnitpushContext()
			try
			{
				=> Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)]moduleDescriptor.=> Either.RightProjection[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)]right.(((org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)) => Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)])Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)]flatMap(((org.apache.ivy.core.module.descriptor.ModuleDescriptor, String))Either[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)]checkModule).=> Either.RightProjection[String,(org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)]right.(((org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)) => Either[String,T])Either[String,T]flatMap { (org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)mdAndConf =>
					(org.apache.ivy.Ivy,org.apache.ivy.core.module.descriptor.ModuleDescriptor,String)Either[String,T]doWithIvy(org.apache.ivy.Ivyivy, (org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)mdAndConf.=> org.apache.ivy.core.module.descriptor.ModuleDescriptor_1, (org.apache.ivy.core.module.descriptor.ModuleDescriptor, String)mdAndConf.=> String_2)
				}
			}
			finally { org.apache.ivy.Ivyivy.()UnitpopContext() }
		}
	}
	/** Checks the immediate dependencies of module for dependencies on scala jars and verifies that the version on the
	* dependencies matches scalaVersion. */
	private def (org.apache.ivy.core.module.descriptor.ModuleDescriptor,String,Iterable[sbt.Configuration])Option[String]checkDependencies(org.apache.ivy.core.module.descriptor.ModuleDescriptormodule: org.apache.ivy.core.module.descriptor.ModuleDescriptorModuleDescriptor, StringscalaVersion: StringString, Iterable[sbt.Configuration]configurations: Iterable[sbt.Configuration]Iterable[Configuration]): Option[String]Option[String] =
	{
		val scala.collection.mutable.Set[String]configSet =(Iterable[sbt.Configuration])scala.collection.mutable.Set[String]configurationSet(Iterable[sbt.Configuration]configurations)
		object sbt.ControlControl.(List[org.apache.ivy.core.module.descriptor.DependencyDescriptor])((org.apache.ivy.core.module.descriptor.DependencyDescriptor) => Option[String])Option[String]lazyFold(org.apache.ivy.core.module.descriptor.ModuleDescriptormodule.()Array[org.apache.ivy.core.module.descriptor.DependencyDescriptor]getDependencies.=> List[org.apache.ivy.core.module.descriptor.DependencyDescriptor]toList)
		{ org.apache.ivy.core.module.descriptor.DependencyDescriptordep =>
			val org.apache.ivy.core.module.id.ModuleRevisionIdid = org.apache.ivy.core.module.descriptor.DependencyDescriptordep.()org.apache.ivy.core.module.id.ModuleRevisionIdgetDependencyRevisionId
			Option[String]if(org.apache.ivy.core.module.id.ModuleRevisionIdid.()java.lang.StringgetOrganisation (AnyRef)Boolean== => java.lang.StringScalaOrganization (Boolean)Boolean&& org.apache.ivy.core.module.id.ModuleRevisionIdid.()java.lang.StringgetRevision (AnyRef)Boolean!= StringscalaVersion (Boolean)Boolean&& org.apache.ivy.core.module.descriptor.DependencyDescriptordep.()Array[java.lang.String]getModuleConfigurations.((java.lang.String) => Boolean)Booleanexists(scala.collection.mutable.Set[String]configSet.(String)Booleancontains))
				(java.lang.String)Some[java.lang.String]Some(java.lang.String("Different Scala version specified in dependency (")"Different Scala version specified in dependency ("(Any)java.lang.String+ org.apache.ivy.core.module.id.ModuleRevisionIdid.()java.lang.StringgetRevision (Any)java.lang.String+ java.lang.String(") than in project (")") than in project (" (Any)java.lang.String+ StringscalaVersion (Any)java.lang.String+ java.lang.String(").")").")
			else
				object NoneNone
		}
	}
	private def (Iterable[sbt.Configuration])scala.collection.mutable.Set[String]configurationSet(Iterable[sbt.Configuration]configurations: Iterable[sbt.Configuration]Iterable[Configuration]) =
		(String*)scala.collection.mutable.Set[String]HashSet(Iterable[sbt.Configuration]configurations.((sbt.Configuration) => String)Iterable[String]map(sbt.Configuration_.()StringtoString).=> Seq[String]toSeq : _*)
	/** Adds exclusions for the scala library and compiler jars so that they are not downloaded.  This is
	* done because normally these jars are already on the classpath and cannot/should not be overridden.  The version
	* of Scala to use is done by setting scala.version in the project definition. */
	private def (org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor,Iterable[sbt.Configuration])UnitexcludeScalaJars(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormodule: org.apache.ivy.core.module.descriptor.DefaultModuleDescriptorDefaultModuleDescriptor, Iterable[sbt.Configuration]configurations: Iterable[sbt.Configuration]Iterable[Configuration])
	{
		val Array[java.lang.String]configurationNames =
		{
			val Array[java.lang.String]names = org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormodule.()Array[java.lang.String]getConfigurationsNames
			Array[java.lang.String]if(Iterable[sbt.Configuration]configurations.=> BooleanisEmpty)
				Array[java.lang.String]names
			else
			{
				import scala.collection.mutable.HashSet
				val scala.collection.mutable.Set[String]configSet = (Iterable[sbt.Configuration])scala.collection.mutable.Set[String]configurationSet(Iterable[sbt.Configuration]configurations)
				scala.collection.mutable.Set[String]configSet.(scala.collection.mutable.Set[String])Unitintersect((java.lang.String*)scala.collection.mutable.Set[java.lang.String]HashSet(Array[java.lang.String]names : _*))
				scala.collection.mutable.Set[String]configSet.Array[String]toArray
			}
		}
		def (String)UnitexcludeScalaJar(Stringname: StringString)
			{ org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormodule.(org.apache.ivy.core.module.descriptor.ExcludeRule)UnitaddExcludeRule((String,String,Iterable[String])org.apache.ivy.core.module.descriptor.ExcludeRuleexcludeRule(=> java.lang.StringScalaOrganization, Stringname, Array[java.lang.String]configurationNames)) }
		(String)UnitexcludeScalaJar(=> java.lang.StringScalaLibraryID)
		(String)UnitexcludeScalaJar(=> java.lang.StringScalaCompilerID)
	}
	/** Creates an ExcludeRule that excludes artifacts with the given module organization and name for
	* the given configurations. */
	private def (String,String,Iterable[String])org.apache.ivy.core.module.descriptor.ExcludeRuleexcludeRule(Stringorganization: StringString, Stringname: StringString, Iterable[String]configurationNames: Iterable[String]Iterable[String]): org.apache.ivy.core.module.descriptor.ExcludeRuleExcludeRule =
	{
		val org.apache.ivy.core.module.id.ArtifactIdartifact = org.apache.ivy.core.module.id.ArtifactIdnew org.apache.ivy.core.module.id.ArtifactIdArtifactId(object org.apache.ivy.core.module.id.ModuleIdModuleId.(java.lang.String,java.lang.String)org.apache.ivy.core.module.id.ModuleIdnewInstance(Stringorganization, Stringname), java.lang.String("*")"*", java.lang.String("*")"*", java.lang.String("*")"*")
		val org.apache.ivy.core.module.descriptor.DefaultExcludeRulerule = org.apache.ivy.core.module.descriptor.DefaultExcludeRulenew org.apache.ivy.core.module.descriptor.DefaultExcludeRuleDefaultExcludeRule(org.apache.ivy.core.module.id.ArtifactIdartifact, object org.apache.ivy.plugins.matcher.ExactPatternMatcherExactPatternMatcher.org.apache.ivy.plugins.matcher.ExactPatternMatcherINSTANCE, object java.util.CollectionsCollections.()java.util.Map[AnyRef,AnyRef]emptyMap[AnyRefAnyRef,AnyRefAnyRef])
		Iterable[String]configurationNames.((String) => Unit)Unitforeach(org.apache.ivy.core.module.descriptor.DefaultExcludeRulerule.(java.lang.String)UnitaddConfiguration)
		org.apache.ivy.core.module.descriptor.DefaultExcludeRulerule
	}
	/** Clears the Ivy cache, as configured by 'config'. */
	def (sbt.IvyConfiguration)Option[String]cleanCache(sbt.IvyConfigurationconfig: sbt.IvyConfigurationIvyConfiguration) =
	{
		def (org.apache.ivy.Ivy,org.apache.ivy.core.module.descriptor.ModuleDescriptor,String)Option[String]doClean(org.apache.ivy.Ivyivy: org.apache.ivy.IvyIvy, org.apache.ivy.core.module.descriptor.ModuleDescriptormodule: org.apache.ivy.core.module.descriptor.ModuleDescriptorModuleDescriptor, Stringdefault: StringString) =
			object sbt.ControlControl.(=> String,sbt.Logger)(=> Option[String])Option[String]trapUnit(java.lang.String("Could not clean cache: ")"Could not clean cache: ", sbt.IvyConfigurationconfig.=> sbt.Loggerlog)
				{ org.apache.ivy.Ivyivy.()org.apache.ivy.core.settings.IvySettingsgetSettings.()Array[org.apache.ivy.core.cache.RepositoryCacheManager]getRepositoryCacheManagers.((org.apache.ivy.core.cache.RepositoryCacheManager) => Unit)Unitforeach(org.apache.ivy.core.cache.RepositoryCacheManager_.()Unitclean()); object NoneNone }
		
		(sbt.IvyConfiguration)((org.apache.ivy.Ivy, org.apache.ivy.core.module.descriptor.ModuleDescriptor, String) => Option[String])Option[String]withIvy(sbt.IvyConfigurationconfig)((org.apache.ivy.Ivy,org.apache.ivy.core.module.descriptor.ModuleDescriptor,String)Option[String]doClean)
	}
	/** Creates a Maven pom from the given Ivy configuration*/
	def (sbt.IvyConfiguration,Iterable[sbt.ModuleID],java.io.File)Option[String]makePom(sbt.IvyConfigurationconfig: sbt.IvyConfigurationIvyConfiguration, Iterable[sbt.ModuleID]extraDependencies: Iterable[sbt.ModuleID]Iterable[ModuleID], java.io.Fileoutput: java.io.FileFile) =
	{
		def (org.apache.ivy.Ivy,org.apache.ivy.core.module.descriptor.ModuleDescriptor,String)Option[String]doMakePom(org.apache.ivy.Ivyivy: org.apache.ivy.IvyIvy, org.apache.ivy.core.module.descriptor.ModuleDescriptormd: org.apache.ivy.core.module.descriptor.ModuleDescriptorModuleDescriptor, Stringdefault: StringString) =
			object sbt.ControlControl.(=> String,sbt.Logger)(=> Option[String])Option[String]trapUnit(java.lang.String("Could not make pom: ")"Could not make pom: ", sbt.IvyConfigurationconfig.=> sbt.Loggerlog)
			{
				val org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormodule = (org.apache.ivy.Ivy,org.apache.ivy.core.module.descriptor.ModuleDescriptor,String,Iterable[sbt.ModuleID])org.apache.ivy.core.module.descriptor.DefaultModuleDescriptoraddLateDependencies(org.apache.ivy.Ivyivy, org.apache.ivy.core.module.descriptor.ModuleDescriptormd, object sbt.ConfigurationsConfigurations.=> sbt.ConfigurationCompile.=> Stringname, Iterable[sbt.ModuleID]extraDependencies)
				object org.apache.ivy.plugins.parser.m2.PomModuleDescriptorWriterPomModuleDescriptorWriter.(org.apache.ivy.core.module.descriptor.ModuleDescriptor,org.apache.ivy.plugins.parser.m2.PomModuleDescriptorWriter.ConfigurationScopeMapping,java.io.File)Unitwrite(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormodule, object sbt.DefaultConfigurationMappingDefaultConfigurationMapping, java.io.Fileoutput)
				object NoneNone
			}
		(sbt.IvyConfiguration)((org.apache.ivy.Ivy, org.apache.ivy.core.module.descriptor.ModuleDescriptor, String) => Option[String])Option[String]withIvy(sbt.IvyConfigurationconfig)((org.apache.ivy.Ivy,org.apache.ivy.core.module.descriptor.ModuleDescriptor,String)Option[String]doMakePom)
	}
	private def (String,org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor)UnitaddDefaultArtifact(StringdefaultConf: StringString, org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormoduleID: org.apache.ivy.core.module.descriptor.DefaultModuleDescriptorDefaultModuleDescriptor) =
		org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormoduleID.(java.lang.String,org.apache.ivy.core.module.descriptor.Artifact)UnitaddArtifact(StringdefaultConf, org.apache.ivy.core.module.descriptor.MDArtifactnew org.apache.ivy.core.module.descriptor.MDArtifactMDArtifact(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormoduleID, org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormoduleID.()org.apache.ivy.core.module.id.ModuleRevisionIdgetModuleRevisionId.()java.lang.StringgetName, java.lang.String("jar")"jar", java.lang.String("jar")"jar"))
	// todo: correct default configuration for extra dependencies
	private def (org.apache.ivy.Ivy,org.apache.ivy.core.module.descriptor.ModuleDescriptor,String,Iterable[sbt.ModuleID])org.apache.ivy.core.module.descriptor.DefaultModuleDescriptoraddLateDependencies(org.apache.ivy.Ivyivy: org.apache.ivy.IvyIvy, org.apache.ivy.core.module.descriptor.ModuleDescriptormd: org.apache.ivy.core.module.descriptor.ModuleDescriptorModuleDescriptor, StringdefaultConfiguration: StringString, Iterable[sbt.ModuleID]extraDependencies: Iterable[sbt.ModuleID]Iterable[ModuleID]) =
	{
		val org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormodule = (org.apache.ivy.core.module.descriptor.ModuleDescriptor)org.apache.ivy.core.module.descriptor.DefaultModuleDescriptortoDefaultModuleDescriptor(org.apache.ivy.core.module.descriptor.ModuleDescriptormd)
		val sbt.ManageDependencies.CustomXmlParser.CustomParserparser = sbt.ManageDependencies.CustomXmlParser.CustomParsernew object sbt.ManageDependencies.CustomXmlParserCustomXmlParser.sbt.ManageDependencies.CustomXmlParser.CustomParserCustomParser(org.apache.ivy.Ivyivy.()org.apache.ivy.core.settings.IvySettingsgetSettings)
		sbt.ManageDependencies.CustomXmlParser.CustomParserparser.(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor)UnitsetMd(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormodule)
		sbt.ManageDependencies.CustomXmlParser.CustomParserparser.(String)UnitsetDefaultConf(java.lang.String("compile->default")"compile->default")//defaultConfiguration)
		(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor,Iterable[sbt.ModuleID],sbt.ManageDependencies.CustomXmlParser.CustomParser)UnitaddDependencies(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormodule, Iterable[sbt.ModuleID]extraDependencies, sbt.ManageDependencies.CustomXmlParser.CustomParserparser)
		org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormodule
	}
	private def (Option[Iterable[sbt.Configuration]],AnyRef{def setConfs(Array[String]): AnyRef})UnitaddConfigurations(Option[Iterable[sbt.Configuration]]configurations: Option[Iterable[sbt.Configuration]]Option[Iterable[Configuration]], <refinement> extends AnyRefto: <refinement> extends AnyRef{ def setConfs(c: Array[String]): AnyRef })
		{ for(((Iterable[sbt.Configuration]) => Unit)Unitconfs <- Option[Iterable[sbt.Configuration]]configurations) { <refinement> extends AnyRefto.(Array[String])AnyRefsetConfs(Iterable[sbt.Configuration]confs.((sbt.Configuration) => String)Iterable[String]map(sbt.Configuration_.=> Stringname).=> List[String]toList.Array[String]toArray) } }
	def (sbt.IvyConfiguration,sbt.UpdateConfiguration,String,String,Iterable[sbt.ModuleID],Option[Iterable[sbt.Configuration]])Option[String]deliver(sbt.IvyConfigurationivyConfig: sbt.IvyConfigurationIvyConfiguration, sbt.UpdateConfigurationupdateConfig: sbt.UpdateConfigurationUpdateConfiguration, Stringstatus: StringString, StringdeliverIvyPattern: StringString, Iterable[sbt.ModuleID]extraDependencies: Iterable[sbt.ModuleID]Iterable[ModuleID], Option[Iterable[sbt.Configuration]]configurations: Option[Iterable[sbt.Configuration]]Option[Iterable[Configuration]]) =
	{
		def (org.apache.ivy.Ivy,org.apache.ivy.core.module.descriptor.ModuleDescriptor,String)Option[String]doDeliver(org.apache.ivy.Ivyivy: org.apache.ivy.IvyIvy, org.apache.ivy.core.module.descriptor.ModuleDescriptormd: org.apache.ivy.core.module.descriptor.ModuleDescriptorModuleDescriptor, Stringdefault: StringString) =
			object sbt.ControlControl.(=> String,sbt.Logger)(=> Option[String])Option[String]trapUnit(java.lang.String("Could not deliver: ")"Could not deliver: ", sbt.IvyConfigurationivyConfig.=> sbt.Loggerlog)
			{
				val org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormodule = (org.apache.ivy.Ivy,org.apache.ivy.core.module.descriptor.ModuleDescriptor,String,Iterable[sbt.ModuleID])org.apache.ivy.core.module.descriptor.DefaultModuleDescriptoraddLateDependencies(org.apache.ivy.Ivyivy, org.apache.ivy.core.module.descriptor.ModuleDescriptormd, Stringdefault, Iterable[sbt.ModuleID]extraDependencies)
				(org.apache.ivy.Ivy,sbt.UpdateConfiguration,org.apache.ivy.core.module.descriptor.ModuleDescriptor)Option[String]resolve(org.apache.ivy.Ivyivy, sbt.UpdateConfigurationupdateConfig, org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormodule) (=> Option[String])Option[String]orElse
				{
					val org.apache.ivy.core.module.id.ModuleRevisionIdrevID = org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormodule.()org.apache.ivy.core.module.id.ModuleRevisionIdgetModuleRevisionId
					val org.apache.ivy.core.deliver.DeliverOptionsoptions = object org.apache.ivy.core.deliver.DeliverOptionsDeliverOptions.(org.apache.ivy.core.settings.IvySettings)org.apache.ivy.core.deliver.DeliverOptionsnewInstance(org.apache.ivy.Ivyivy.()org.apache.ivy.core.settings.IvySettingsgetSettings).(java.lang.String)org.apache.ivy.core.deliver.DeliverOptionssetStatus(Stringstatus)
					(Option[Iterable[sbt.Configuration]],AnyRef{def setConfs(Array[String]): AnyRef})UnitaddConfigurations(Option[Iterable[sbt.Configuration]]configurations, org.apache.ivy.core.deliver.DeliverOptionsoptions)
					
					org.apache.ivy.Ivyivy.(org.apache.ivy.core.module.id.ModuleRevisionId,java.lang.String,java.lang.String,org.apache.ivy.core.deliver.DeliverOptions)Unitdeliver(org.apache.ivy.core.module.id.ModuleRevisionIdrevID, org.apache.ivy.core.module.id.ModuleRevisionIdrevID.()java.lang.StringgetRevision, StringdeliverIvyPattern, org.apache.ivy.core.deliver.DeliverOptionsoptions)
					object NoneNone
				}
			}
		(sbt.IvyConfiguration)((org.apache.ivy.Ivy, org.apache.ivy.core.module.descriptor.ModuleDescriptor, String) => Option[String])Option[String]withIvy(sbt.IvyConfigurationivyConfig)((org.apache.ivy.Ivy,org.apache.ivy.core.module.descriptor.ModuleDescriptor,String)Option[String]doDeliver)
	}
	// todo: map configurations, extra dependencies
	def (sbt.IvyConfiguration,String,Iterable[String],String,Option[Iterable[sbt.Configuration]])Option[String]publish(sbt.IvyConfigurationivyConfig: sbt.IvyConfigurationIvyConfiguration, StringresolverName: StringString, Iterable[String]srcArtifactPatterns: Iterable[String]Iterable[String], StringdeliveredIvyPattern: StringString, Option[Iterable[sbt.Configuration]]configurations: Option[Iterable[sbt.Configuration]]Option[Iterable[Configuration]]) =
	{
		def (org.apache.ivy.Ivy,org.apache.ivy.core.module.descriptor.ModuleDescriptor,String)Option[String]doPublish(org.apache.ivy.Ivyivy: org.apache.ivy.IvyIvy, org.apache.ivy.core.module.descriptor.ModuleDescriptormd: org.apache.ivy.core.module.descriptor.ModuleDescriptorModuleDescriptor, Stringdefault: StringString) =
			object sbt.ControlControl.(=> String,sbt.Logger)(=> Option[String])Option[String]trapUnit(java.lang.String("Could not publish: ")"Could not publish: ", sbt.IvyConfigurationivyConfig.=> sbt.Loggerlog)
			{
				val org.apache.ivy.core.module.id.ModuleRevisionIdrevID = org.apache.ivy.core.module.descriptor.ModuleDescriptormd.()org.apache.ivy.core.module.id.ModuleRevisionIdgetModuleRevisionId
				val java.util.ArrayList[String]patterns = ()java.util.ArrayList[String]new java.util.java.util.ArrayList[String]ArrayList[String]
				Iterable[String]srcArtifactPatterns.((String) => Unit)Unitforeach(Stringpattern => java.util.ArrayList[String]patterns.(String)Booleanadd(Stringpattern))
				val org.apache.ivy.core.publish.PublishOptionsoptions = (org.apache.ivy.core.publish.PublishOptionsnew org.apache.ivy.core.publish.PublishOptionsPublishOptions).(java.lang.String)org.apache.ivy.core.publish.PublishOptionssetSrcIvyPattern(StringdeliveredIvyPattern).(Boolean)org.apache.ivy.core.publish.PublishOptionssetOverwrite(Boolean(true)true)
				(Option[Iterable[sbt.Configuration]],AnyRef{def setConfs(Array[String]): AnyRef})UnitaddConfigurations(Option[Iterable[sbt.Configuration]]configurations, org.apache.ivy.core.publish.PublishOptionsoptions)
				org.apache.ivy.Ivyivy.(org.apache.ivy.core.module.id.ModuleRevisionId,java.util.Collection[_],java.lang.String,org.apache.ivy.core.publish.PublishOptions)java.util.Collection[_]publish(org.apache.ivy.core.module.id.ModuleRevisionIdrevID, java.util.ArrayList[String]patterns, StringresolverName, org.apache.ivy.core.publish.PublishOptionsoptions)
				object NoneNone
			}
		(sbt.IvyConfiguration)((org.apache.ivy.Ivy, org.apache.ivy.core.module.descriptor.ModuleDescriptor, String) => Option[String])Option[String]withIvy(sbt.IvyConfigurationivyConfig)((org.apache.ivy.Ivy,org.apache.ivy.core.module.descriptor.ModuleDescriptor,String)Option[String]doPublish)
	}
	/** Resolves and retrieves dependencies.  'ivyConfig' is used to produce an Ivy file and configuration.
	* 'updateConfig' configures the actual resolution and retrieval process. */
	def (sbt.IvyConfiguration,sbt.UpdateConfiguration)Option[String]update(sbt.IvyConfigurationivyConfig: sbt.IvyConfigurationIvyConfiguration, sbt.UpdateConfigurationupdateConfig: sbt.UpdateConfigurationUpdateConfiguration) =
	{
		def (org.apache.ivy.Ivy,org.apache.ivy.core.module.descriptor.ModuleDescriptor,String)Option[String]processModule(org.apache.ivy.Ivyivy: org.apache.ivy.IvyIvy, org.apache.ivy.core.module.descriptor.ModuleDescriptormodule: org.apache.ivy.core.module.descriptor.ModuleDescriptorModuleDescriptor, Stringdefault: StringString) =
		{
			import updateConfig._
			object sbt.ControlControl.(=> String,sbt.Logger)(=> Option[String])Option[String]trapUnit(java.lang.String("Could not process dependencies: ")"Could not process dependencies: ", sbt.IvyConfigurationivyConfig.=> sbt.Loggerlog)
			{
				(org.apache.ivy.Ivy,sbt.UpdateConfiguration,org.apache.ivy.core.module.descriptor.ModuleDescriptor)Option[String]resolve(org.apache.ivy.Ivyivy, sbt.UpdateConfigurationupdateConfig, org.apache.ivy.core.module.descriptor.ModuleDescriptormodule) (=> Option[String])Option[String]orElse
				{
					val org.apache.ivy.core.retrieve.RetrieveOptionsretrieveOptions = org.apache.ivy.core.retrieve.RetrieveOptionsnew org.apache.ivy.core.retrieve.RetrieveOptionsRetrieveOptions
					org.apache.ivy.core.retrieve.RetrieveOptionsretrieveOptions.(Boolean)org.apache.ivy.core.retrieve.RetrieveOptionssetSync(=> Booleansynchronize)
					val java.lang.StringpatternBase = sbt.IvyConfigurationivyConfig.=> sbt.IvyPathspaths.=> sbt.PathmanagedLibDirectory.=> java.io.FileasFile.()java.lang.StringgetCanonicalPath
					val java.lang.Stringpattern =
						java.lang.Stringif(java.lang.StringpatternBase.(java.lang.String)BooleanendsWith(object java.io.FileFile.java.lang.Stringseparator))
							java.lang.StringpatternBase (Any)java.lang.String+ => StringoutputPattern
						else
							java.lang.StringpatternBase (Any)java.lang.String+ object java.io.FileFile.CharseparatorChar (Any)java.lang.String+ => StringoutputPattern
					org.apache.ivy.Ivyivy.(org.apache.ivy.core.module.id.ModuleRevisionId,java.lang.String,org.apache.ivy.core.retrieve.RetrieveOptions)Intretrieve(org.apache.ivy.core.module.descriptor.ModuleDescriptormodule.()org.apache.ivy.core.module.id.ModuleRevisionIdgetModuleRevisionId, java.lang.Stringpattern, org.apache.ivy.core.retrieve.RetrieveOptionsretrieveOptions)
					object NoneNone
				}
			}
		}
		
		(sbt.IvyConfiguration)((org.apache.ivy.Ivy, org.apache.ivy.core.module.descriptor.ModuleDescriptor, String) => Option[String])Option[String]withIvy(sbt.IvyConfigurationivyConfig)((org.apache.ivy.Ivy,org.apache.ivy.core.module.descriptor.ModuleDescriptor,String)Option[String]processModule)
	}
	private def (org.apache.ivy.Ivy,sbt.UpdateConfiguration,org.apache.ivy.core.module.descriptor.ModuleDescriptor)Option[String]resolve(org.apache.ivy.Ivyivy: org.apache.ivy.IvyIvy, sbt.UpdateConfigurationupdateConfig: sbt.UpdateConfigurationUpdateConfiguration, org.apache.ivy.core.module.descriptor.ModuleDescriptormodule: org.apache.ivy.core.module.descriptor.ModuleDescriptorModuleDescriptor) =
	{
		import updateConfig._
		val org.apache.ivy.core.resolve.ResolveOptionsresolveOptions = org.apache.ivy.core.resolve.ResolveOptionsnew org.apache.ivy.core.resolve.ResolveOptionsResolveOptions
		Anyif(=> Booleanquiet)
			org.apache.ivy.core.resolve.ResolveOptionsresolveOptions.(java.lang.String)org.apache.ivy.core.LogOptionssetLog(LogOptions.java.lang.String("download-only")LOG_DOWNLOAD_ONLY)
		val org.apache.ivy.core.report.ResolveReportresolveReport = org.apache.ivy.Ivyivy.(org.apache.ivy.core.module.descriptor.ModuleDescriptor,org.apache.ivy.core.resolve.ResolveOptions)org.apache.ivy.core.report.ResolveReportresolve(org.apache.ivy.core.module.descriptor.ModuleDescriptormodule, org.apache.ivy.core.resolve.ResolveOptionsresolveOptions)
		Option[String]if(org.apache.ivy.core.report.ResolveReportresolveReport.()BooleanhasError)
			(String)Some[String]Some((java.lang.Object*)scala.collection.immutable.Set[java.lang.Object]Set(org.apache.ivy.core.report.ResolveReportresolveReport.()java.util.List[_]getAllProblemMessages.()Array[java.lang.Object]toArray: _*).(String)StringmkString(object java.lang.SystemSystem.(java.lang.String)java.lang.StringgetProperty(java.lang.String("line.separator")"line.separator")))
		else
			object NoneNone
	}
	/** This method is used to add inline dependencies to the provided module. */
	private def (org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor,Iterable[sbt.ModuleID],sbt.ManageDependencies.CustomXmlParser.CustomParser)UnitaddDependencies(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormoduleID: org.apache.ivy.core.module.descriptor.DefaultModuleDescriptorDefaultModuleDescriptor, Iterable[sbt.ModuleID]dependencies: Iterable[sbt.ModuleID]Iterable[ModuleID], sbt.ManageDependencies.CustomXmlParser.CustomParserparser: CustomXmlParser.sbt.ManageDependencies.CustomXmlParser.CustomParserCustomParser)
	{
		for(((sbt.ModuleID) => Unit)Unitdependency <- Iterable[sbt.ModuleID]dependencies)
		{
			//println("Adding dependency " + dependency + " (default:  " + parser.getDefaultConf + ")")
			val org.apache.ivy.core.module.descriptor.DefaultDependencyDescriptordependencyDescriptor = org.apache.ivy.core.module.descriptor.DefaultDependencyDescriptornew org.apache.ivy.core.module.descriptor.DefaultDependencyDescriptorDefaultDependencyDescriptor(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormoduleID, (sbt.ModuleID)org.apache.ivy.core.module.id.ModuleRevisionIdtoID(sbt.ModuleIDdependency), Boolean(false)false, Boolean(false)false, Boolean(true)true)
			sbt.ModuleIDdependency.=> Option[String]configurations Unitmatch
			{
				Unitcase object NoneNone => // The configuration for this dependency was not explicitly specified, so use the default
					sbt.ManageDependencies.CustomXmlParser.CustomParserparser.(String,org.apache.ivy.core.module.descriptor.DefaultDependencyDescriptor)UnitparseDepsConfs(sbt.ManageDependencies.CustomXmlParser.CustomParserparser.()java.lang.StringgetDefaultConf, org.apache.ivy.core.module.descriptor.DefaultDependencyDescriptordependencyDescriptor)
				Unitcase Some(Stringconfs) => // The configuration mapping (looks like: test->default) was specified for this dependency
					sbt.ManageDependencies.CustomXmlParser.CustomParserparser.(String,org.apache.ivy.core.module.descriptor.DefaultDependencyDescriptor)UnitparseDepsConfs(Stringconfs, org.apache.ivy.core.module.descriptor.DefaultDependencyDescriptordependencyDescriptor)
			}
			org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormoduleID.(org.apache.ivy.core.module.descriptor.DependencyDescriptor)UnitaddDependency(org.apache.ivy.core.module.descriptor.DefaultDependencyDescriptordependencyDescriptor)
		}
	}
	private def (java.io.File)java.net.URLtoURL(java.io.Filefile: java.io.FileFile) = java.io.Filefile.()java.net.URItoURI.()java.net.URLtoURL
	/** Adds the ivy.xml main artifact. */
	private def (org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor)UnitaddMainArtifact(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormoduleID: org.apache.ivy.core.module.descriptor.DefaultModuleDescriptorDefaultModuleDescriptor)
	{
		val org.apache.ivy.core.module.descriptor.Artifactartifact = object org.apache.ivy.core.module.descriptor.DefaultArtifactDefaultArtifact.(org.apache.ivy.core.module.id.ModuleRevisionId,java.util.Date)org.apache.ivy.core.module.descriptor.ArtifactnewIvyArtifact(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormoduleID.()org.apache.ivy.core.module.id.ModuleRevisionIdgetResolvedModuleRevisionId, org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormoduleID.()java.util.DategetPublicationDate)
		org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormoduleID.(org.apache.ivy.core.module.descriptor.Artifact)UnitsetModuleArtifact(org.apache.ivy.core.module.descriptor.Artifactartifact)
		org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormoduleID.()Unitcheck()
	}
	/** Sets the resolvers for 'settings' to 'resolvers'.  This is done by creating a new chain and making it the default. */
	private def (org.apache.ivy.core.settings.IvySettings,Iterable[sbt.Resolver],sbt.Logger)UnitaddResolvers(org.apache.ivy.core.settings.IvySettingssettings: org.apache.ivy.core.settings.IvySettingsIvySettings, Iterable[sbt.Resolver]resolvers: Iterable[sbt.Resolver]Iterable[Resolver], sbt.Loggerlog: sbt.LoggerLogger)
	{
		val org.apache.ivy.plugins.resolver.ChainResolvernewDefault = org.apache.ivy.plugins.resolver.ChainResolvernew org.apache.ivy.plugins.resolver.ChainResolverChainResolver
		org.apache.ivy.plugins.resolver.ChainResolvernewDefault.(java.lang.String)UnitsetName(java.lang.String("redefined-public")"redefined-public")
		Iterable[sbt.Resolver]resolvers.((sbt.Resolver) => Unit)Unitforeach(sbt.Resolverr => org.apache.ivy.plugins.resolver.ChainResolvernewDefault.(org.apache.ivy.plugins.resolver.DependencyResolver)Unitadd((sbt.Resolver)org.apache.ivy.plugins.resolver.IBiblioResolvergetResolver(sbt.Resolverr)))
		org.apache.ivy.plugins.resolver.ChainResolvernewDefault.(org.apache.ivy.plugins.resolver.DependencyResolver)Unitadd(org.apache.ivy.core.settings.IvySettingssettings.()org.apache.ivy.plugins.resolver.DependencyResolvergetDefaultResolver)
		org.apache.ivy.core.settings.IvySettingssettings.(org.apache.ivy.plugins.resolver.DependencyResolver)UnitaddResolver(org.apache.ivy.plugins.resolver.ChainResolvernewDefault)
		org.apache.ivy.core.settings.IvySettingssettings.(java.lang.String)UnitsetDefaultResolver(org.apache.ivy.plugins.resolver.ChainResolvernewDefault.()java.lang.StringgetName)
		Unitif(sbt.Loggerlog.(sbt.Level.Value)BooleanatLevel(object sbt.LevelLevel.=> sbt.Level.ValueDebug))
		{
			sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Using extra repositories:")"Using extra repositories:")
			Iterable[sbt.Resolver]resolvers.((sbt.Resolver) => Unit)Unitforeach(sbt.Resolverr => sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("\011")"\t" (Any)java.lang.String+ sbt.Resolverr.()java.lang.StringtoString))
		}
	}
	/** Converts the given sbt resolver into an Ivy resolver..*/
	private def (sbt.Resolver)org.apache.ivy.plugins.resolver.IBiblioResolvergetResolver(sbt.Resolverr: sbt.ResolverResolver) =
		sbt.Resolverr org.apache.ivy.plugins.resolver.IBiblioResolvermatch
		{
			org.apache.ivy.plugins.resolver.IBiblioResolvercase sbt.MavenRepositoryrepo: sbt.MavenRepositoryMavenRepository =>
			{
				val org.apache.ivy.plugins.resolver.IBiblioResolverresolver = org.apache.ivy.plugins.resolver.IBiblioResolvernew org.apache.ivy.plugins.resolver.IBiblioResolverIBiblioResolver
				org.apache.ivy.plugins.resolver.IBiblioResolverresolver.(java.lang.String)UnitsetName(sbt.MavenRepositoryrepo.=> Stringname)
				org.apache.ivy.plugins.resolver.IBiblioResolverresolver.(Boolean)UnitsetM2compatible(Boolean(true)true)
				org.apache.ivy.plugins.resolver.IBiblioResolverresolver.(java.lang.String)UnitsetChangingPattern(java.lang.String(".*\-SNAPSHOT")""".*\-SNAPSHOT""")
				org.apache.ivy.plugins.resolver.IBiblioResolverresolver.(java.lang.String)UnitsetRoot(sbt.MavenRepositoryrepo.=> Stringroot)
				org.apache.ivy.plugins.resolver.IBiblioResolverresolver
			}
		}
	/** Converts the given sbt module id into an Ivy ModuleRevisionId.*/
	private def (sbt.ModuleID)org.apache.ivy.core.module.id.ModuleRevisionIdtoID(sbt.ModuleIDm: sbt.ModuleIDModuleID) =
	{
		import m._
		object org.apache.ivy.core.module.id.ModuleRevisionIdModuleRevisionId.(java.lang.String,java.lang.String,java.lang.String)org.apache.ivy.core.module.id.ModuleRevisionIdnewInstance(=> Stringorganization, => Stringname, => Stringrevision)
	}
	/** An implementation of Ivy's Resource class that provides the Ivy file from a byte array.  This is used to support
	* inline Ivy file XML.*/
	private class class ByteResource extends org.apache.ivy.plugins.repository.BasicResource with ScalaObjectByteResource(Array[Byte]bytes: Array[Byte]Array[Byte]) extends
		org.apache.ivy.plugins.repository.BasicResourceBasicResource(java.lang.String("Inline XML dependencies")"Inline XML dependencies", Boolean(true)true, Array[Byte]bytes.implicit scala.Predef.int2long : (Int)Longlength, object java.lang.SystemSystem.()LongcurrentTimeMillis, Boolean(true)true)
	{
		override def ()java.io.ByteArrayInputStreamopenStream = java.io.ByteArrayInputStreamnew java.io.java.io.ByteArrayInputStreamByteArrayInputStream(Array[Byte]bytes)
	}
	/** Subclasses the default Ivy file parser in order to provide access to protected methods.*/
	private object object sbt.ManageDependencies.CustomXmlParserCustomXmlParser extends org.apache.ivy.plugins.parser.xml.XmlModuleDescriptorParserXmlModuleDescriptorParser with NotNullNotNull
	{
		import XmlModuleDescriptorParser.Parser
		class class CustomParser extends org.apache.ivy.plugins.parser.xml.XmlModuleDescriptorParser.Parser with NotNull with ScalaObjectCustomParser(org.apache.ivy.core.settings.IvySettingssettings: org.apache.ivy.core.settings.IvySettingsIvySettings) extends org.apache.ivy.plugins.parser.xml.XmlModuleDescriptorParser.ParserParser(object sbt.ManageDependencies.CustomXmlParserCustomXmlParser, org.apache.ivy.core.settings.IvySettingssettings) with NotNullNotNull
		{
			def (java.net.URL)UnitsetSource(java.net.URLurl: java.net.URLURL) =
			{
				super.(org.apache.ivy.plugins.repository.Resource)UnitsetResource(org.apache.ivy.plugins.repository.url.URLResourcenew org.apache.ivy.plugins.repository.url.URLResourceURLResource(java.net.URLurl))
				super.(java.net.URL)UnitsetInput(java.net.URLurl)
			}
			/** Overridden because the super implementation overwrites the module descriptor.*/
			override def (org.apache.ivy.plugins.repository.Resource)UnitsetResource(org.apache.ivy.plugins.repository.Resourceres: org.apache.ivy.plugins.repository.ResourceResource) Unit{}
			override def (org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor)UnitsetMd(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormd: org.apache.ivy.core.module.descriptor.DefaultModuleDescriptorDefaultModuleDescriptor) = super.(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor)UnitsetMd(org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormd)
			override def (String,org.apache.ivy.core.module.descriptor.DefaultDependencyDescriptor)UnitparseDepsConfs(Stringconfs: StringString, org.apache.ivy.core.module.descriptor.DefaultDependencyDescriptordd: org.apache.ivy.core.module.descriptor.DefaultDependencyDescriptorDefaultDependencyDescriptor) = super.(java.lang.String,org.apache.ivy.core.module.descriptor.DefaultDependencyDescriptor)UnitparseDepsConfs(Stringconfs, org.apache.ivy.core.module.descriptor.DefaultDependencyDescriptordd)
			override def ()java.lang.StringgetDefaultConf = super.()java.lang.StringgetDefaultConf
			override def (String)UnitsetDefaultConf(Stringconf: StringString) = super.(java.lang.String)UnitsetDefaultConf(Stringconf)
		}
	}
	/** This code converts the given ModuleDescriptor to a DefaultModuleDescriptor by casting or generating an error.
	* Ivy always produces a DefaultModuleDescriptor, so this should be reasonable. */
	private def (org.apache.ivy.core.module.descriptor.ModuleDescriptor)org.apache.ivy.core.module.descriptor.DefaultModuleDescriptortoDefaultModuleDescriptor(org.apache.ivy.core.module.descriptor.ModuleDescriptormd: org.apache.ivy.core.module.descriptor.ModuleDescriptorModuleDescriptor) =
		org.apache.ivy.core.module.descriptor.ModuleDescriptormd org.apache.ivy.core.module.descriptor.DefaultModuleDescriptormatch
		{
			org.apache.ivy.core.module.descriptor.DefaultModuleDescriptorcase org.apache.ivy.core.module.descriptor.DefaultModuleDescriptordmd: org.apache.ivy.core.module.descriptor.DefaultModuleDescriptorDefaultModuleDescriptor => org.apache.ivy.core.module.descriptor.DefaultModuleDescriptordmd
			Nothingcase _ => (String)Nothingerror(java.lang.String("Unknown ModuleDescriptor type.")"Unknown ModuleDescriptor type.")
		}
}

private object object sbt.DefaultConfigurationMappingDefaultConfigurationMapping extends object org.apache.ivy.plugins.parser.m2.PomModuleDescriptorWriterPomModuleDescriptorWriter.org.apache.ivy.plugins.parser.m2.PomModuleDescriptorWriter.ConfigurationScopeMappingConfigurationScopeMapping(()java.util.HashMap[Nothing,Nothing]new java.util.java.util.HashMap[Nothing,Nothing]HashMap)
{
	override def (Array[String])java.lang.StringgetScope(Array[String]confs: Array[String]Array[String]) =
	{
		object sbt.ConfigurationsConfigurations.=> List[sbt.Configuration]defaultMavenConfigurations.((sbt.Configuration) => Boolean)Option[sbt.Configuration]find(sbt.Configurationconf => Array[String]confs.(Any)Booleancontains(sbt.Configurationconf.=> Stringname)) java.lang.Stringmatch
		{
			Stringcase Some(sbt.Configurationconf) => sbt.Configurationconf.=> Stringname
			java.lang.Stringcase object NoneNone =>
				java.lang.Stringif(Array[String]confs.=> BooleanisEmpty (Boolean)Boolean|| (Int)Stringconfs(Int(0)0) (AnyRef)Boolean== object sbt.ConfigurationsConfigurations.=> sbt.ConfigurationDefault.=> Stringname)
					Null(null)null
				else
					(Int)Stringconfs(Int(0)0)
		}
	}
	override def (Array[String])BooleanisOptional(Array[String]confs: Array[String]Array[String]) = Array[String]confs.=> BooleanisEmpty (Boolean)Boolean|| (Array[String]confs.=> Intlength (Int)Boolean== Int(1)1 (Boolean)Boolean&& (Int)Stringconfs(Int(0)0) (AnyRef)Boolean== object sbt.ConfigurationsConfigurations.=> sbt.ConfigurationOptional.=> Stringname)
}

sealed abstract class class Manager extends java.lang.Object with NotNull with ScalaObjectManager extends NotNullNotNull
/** This explicitly requests auto detection as a dependency manager.  It will first check for a 'pom.xml' file and if that does not exist, an 'ivy.xml' file.
* Ivy is configured using the detected file or uses defaults.*/
final class class AutoDetectManager extends sbt.Manager with ScalaObjectAutoDetectManager(val sbt.ModuleIDmodule: sbt.ModuleIDModuleID) extends sbt.ManagerManager
/** This explicitly requests that the Maven pom 'pom' be used to determine dependencies.  An Ivy configuration file to use may be specified in
* 'configuration', since Ivy currently cannot extract Maven repositories from a pom file. Otherwise, defaults are used.*/
final class class MavenManager extends sbt.Manager with ScalaObjectMavenManager(val Option[sbt.Path]configuration: Option[sbt.Path]Option[Path], val sbt.Pathpom: sbt.PathPath) extends sbt.ManagerManager
/** This explicitly requests that the Ivy file 'dependencies' be used to determine dependencies.  An Ivy configuration file to use may be specified in
* 'configuration'.  Otherwise, defaults are used.*/
final class class IvyManager extends sbt.Manager with ScalaObjectIvyManager(val Option[sbt.Path]configuration: Option[sbt.Path]Option[Path], val sbt.Pathdependencies: sbt.PathPath) extends sbt.ManagerManager
/** This manager directly specifies the dependencies, resolvers, and configurations through sbt wrapper classes and through an in-memory
* Ivy XML file. */
sealed trait trait SbtManager extends sbt.ManagerSbtManager extends sbt.ManagerManager
{
	def => sbt.ModuleIDmodule: sbt.ModuleIDModuleID
	def => Iterable[sbt.Resolver]resolvers: Iterable[sbt.Resolver]Iterable[Resolver]
	def => Iterable[sbt.ModuleID]dependencies: Iterable[sbt.ModuleID]Iterable[ModuleID]
	def => BooleanautodetectUnspecified: BooleanBoolean
	def => scala.xml.NodeSeqdependenciesXML: scala.xml.scala.xml.NodeSeqNodeSeq
	def => Iterable[sbt.Configuration]configurations: Iterable[sbt.Configuration]Iterable[Configuration]
	def => Option[sbt.Configuration]defaultConfiguration: Option[sbt.Configuration]Option[Configuration]
}
final class class SimpleManager extends sbt.Manager with sbt.SbtManager with ScalaObjectSimpleManager private[sbt] (val scala.xml.NodeSeqdependenciesXML: scala.xml.scala.xml.NodeSeqNodeSeq, val BooleanautodetectUnspecified: BooleanBoolean,
	val sbt.ModuleIDmodule: sbt.ModuleIDModuleID, val Iterable[sbt.Resolver]resolvers: Iterable[sbt.Resolver]Iterable[Resolver], val Iterable[sbt.Configuration]configurations: Iterable[sbt.Configuration]Iterable[Configuration],
	val Option[sbt.Configuration]defaultConfiguration: Option[sbt.Configuration]Option[Configuration], val sbt.ModuleID*dependencies: sbt.ModuleID*ModuleID*) extends sbt.SbtManagerSbtManager

final case class class ModuleID extends java.lang.Object with NotNull with ScalaObject with ProductModuleID(Stringorganization: StringString, Stringname: StringString, Stringrevision: StringString, Option[String]configurations: Option[String]Option[String]) extends NotNullNotNull
{
	def (String,String,String)sbt.ModuleIDthis(Stringorganization: StringString, Stringname: StringString, Stringrevision: StringString) = ModuleID.this.typethis(Stringorganization, Stringname, Stringrevision, object NoneNone)
	override def ()java.lang.StringtoString = => Stringorganization (Any)java.lang.String+ java.lang.String(":")":" (Any)java.lang.String+ => Stringname (Any)java.lang.String+ java.lang.String(":")":" (Any)java.lang.String+ => Stringrevision
}
sealed trait trait Resolver extends java.lang.Object with NotNullResolver extends NotNullNotNull
{
	def => Stringname: StringString
}
sealed case class class MavenRepository extends java.lang.Object with sbt.Resolver with ScalaObject with ProductMavenRepository(Stringname: StringString, Stringroot: StringString) extends sbt.ResolverResolver
{
	override def ()java.lang.StringtoString = => Stringname (Any)java.lang.String+ java.lang.String(": ")": " (Any)java.lang.String+ => Stringroot
}
import Resolver._
object object sbt.ScalaToolsReleasesScalaToolsReleases extends sbt.MavenRepositoryMavenRepository(=> java.lang.StringScalaToolsReleasesName, => java.lang.StringScalaToolsReleasesRoot)
object object sbt.ScalaToolsSnapshotsScalaToolsSnapshots extends sbt.MavenRepositoryMavenRepository(=> java.lang.StringScalaToolsSnapshotsName, => java.lang.StringScalaToolsSnapshotsRoot)
object object sbt.DefaultMavenRepositoryDefaultMavenRepository extends sbt.MavenRepositoryMavenRepository(java.lang.String("Maven2 Repository")"Maven2 Repository", IBiblioResolver.java.lang.String("http://repo1.maven.org/maven2/")DEFAULT_M2_ROOT)

object object sbt.ResolverResolver
{
	val java.lang.StringScalaToolsReleasesName = java.lang.String("Scala-Tools Maven2 Repository")"Scala-Tools Maven2 Repository"
	val java.lang.StringScalaToolsSnapshotsName = java.lang.String("Scala-Tools Maven2 Snapshots Repository")"Scala-Tools Maven2 Snapshots Repository"
	val java.lang.StringScalaToolsReleasesRoot = java.lang.String("http://scala-tools.org/repo-releases")"http://scala-tools.org/repo-releases"
	val java.lang.StringScalaToolsSnapshotsRoot = java.lang.String("http://scala-tools.org/repo-snapshots")"http://scala-tools.org/repo-snapshots"
}
/** Represents an Ivy configuration. */
final class class Configuration extends java.lang.Object with NotNull with ScalaObjectConfiguration(val Stringname: StringString, val Stringdescription: StringString, val BooleanisPublic: BooleanBoolean, val List[sbt.Configuration]extendsConfigs: List[sbt.Configuration]List[Configuration], val Booleantransitive: BooleanBoolean) extends NotNullNotNull {
	(Boolean)Unitrequire(=> Stringname (AnyRef)Boolean!= Null(null)null (Boolean)Boolean&& => Boolean!implicit scala.Predef.stringWrapper : (String)scala.runtime.RichStringname.=> BooleanisEmpty)
	(Boolean)Unitrequire(=> Stringdescription (AnyRef)Boolean!= Null(null)null)
	def (String)sbt.Configurationthis(Stringname: StringString) = Configuration.this.typethis(Stringname, java.lang.String("")"", Boolean(true)true, object NilNil, Boolean(true)true)
	def (String)sbt.ConfigurationdescribedAs(StringnewDescription: StringString) = sbt.Configurationnew sbt.ConfigurationConfiguration(=> Stringname, StringnewDescription, => BooleanisPublic, => List[sbt.Configuration]extendsConfigs, => Booleantransitive)
	def (sbt.Configuration*)sbt.Configurationextend(sbt.Configuration*configs: sbt.Configuration*Configuration*) = sbt.Configurationnew sbt.ConfigurationConfiguration(=> Stringname, => Stringdescription, => BooleanisPublic, sbt.Configuration*configs.=> List[sbt.Configuration]toList (List[sbt.Configuration])List[sbt.Configuration]::: => List[sbt.Configuration]extendsConfigs, => Booleantransitive)
	def => sbt.ConfigurationnotTransitive = sbt.Configurationnew sbt.ConfigurationConfiguration(=> Stringname, => Stringdescription, => BooleanisPublic, => List[sbt.Configuration]extendsConfigs, Boolean(false)false)
	def => sbt.Configurationhide = sbt.Configurationnew sbt.ConfigurationConfiguration(=> Stringname, => Stringdescription, Boolean(false)false, => List[sbt.Configuration]extendsConfigs, => Booleantransitive)
	override def ()StringtoString = => Stringname
	import org.apache.ivy.core.module.descriptor.{Configuration => IvyConfig}
	import IvyConfig.Visibility._
	def => org.apache.ivy.core.module.descriptor.ConfigurationtoIvyConfiguration = (java.lang.String,org.apache.ivy.core.module.descriptor.Configuration.Visibility,java.lang.String,Array[java.lang.String],Boolean,java.lang.String)org.apache.ivy.core.module.descriptor.Configurationnew org.apache.ivy.core.module.descriptor.ConfigurationIvyConfig(=> Stringname, org.apache.ivy.core.module.descriptor.Configuration.Visibilityif(=> BooleanisPublic) org.apache.ivy.core.module.descriptor.Configuration.VisibilityPUBLIC else org.apache.ivy.core.module.descriptor.Configuration.VisibilityPRIVATE, => Stringdescription, => List[sbt.Configuration]extendsConfigs.((sbt.Configuration) => String)List[String]map(sbt.Configuration_.=> Stringname).Array[String]toArray, => Booleantransitive, Null(null)null)
}
object object sbt.ConfigurationsConfigurations
{
	def (String)sbt.Configurationconfig(Stringname: StringString) = (String)sbt.Configurationnew sbt.ConfigurationConfiguration(Stringname)
	def => List[sbt.Configuration]defaultMavenConfigurations = => sbt.ConfigurationCompile (sbt.Configuration)List[sbt.Configuration]:: => sbt.ConfigurationRuntime (sbt.Configuration)List[sbt.Configuration]:: => sbt.ConfigurationTest (sbt.Configuration)List[sbt.Configuration]:: => sbt.ConfigurationProvided (sbt.Configuration)List[sbt.Configuration]:: => sbt.ConfigurationSystem (sbt.Configuration)List[sbt.Configuration]:: => sbt.ConfigurationOptional (sbt.Configuration)List[sbt.Configuration]:: => sbt.ConfigurationSources (sbt.Configuration)List[sbt.Configuration]:: => sbt.ConfigurationJavadoc (sbt.Configuration)List[sbt.Configuration]:: object NilNil
	
	lazy val sbt.ConfigurationDefault = (String)sbt.Configurationconfig(java.lang.String("default")"default")
	lazy val sbt.ConfigurationCompile = (String)sbt.Configurationconfig(java.lang.String("compile")"compile")
	lazy val sbt.ConfigurationIntegrationTest = (String)sbt.Configurationconfig(java.lang.String("it")"it")
	lazy val sbt.ConfigurationProvided = (String)sbt.Configurationconfig(java.lang.String("provided")"provided")
	lazy val sbt.ConfigurationJavadoc = (String)sbt.Configurationconfig(java.lang.String("javadoc")"javadoc")
	lazy val sbt.ConfigurationRuntime = (String)sbt.Configurationconfig(java.lang.String("runtime")"runtime")
	lazy val sbt.ConfigurationTest = (String)sbt.Configurationconfig(java.lang.String("test")"test") => sbt.Configurationhide
	lazy val sbt.ConfigurationSources = (String)sbt.Configurationconfig(java.lang.String("sources")"sources")
	lazy val sbt.ConfigurationSystem = (String)sbt.Configurationconfig(java.lang.String("system")"system")
	lazy val sbt.ConfigurationOptional = (String)sbt.Configurationconfig(java.lang.String("optional")"optional")
	
	private[sbt] def (Iterable[sbt.Configuration])scala.collection.immutable.Set[sbt.Configuration]removeDuplicates(Iterable[sbt.Configuration]configs: Iterable[sbt.Configuration]Iterable[Configuration]) = (sbt.Configuration*)scala.collection.immutable.Set[sbt.Configuration]Set(scala.collection.mutable.((String, sbt.Configuration)*)scala.collection.mutable.Map[String,sbt.Configuration]Map(Iterable[sbt.Configuration]configs.((sbt.Configuration) => (String, sbt.Configuration))Iterable[(String, sbt.Configuration)]map(sbt.Configurationconfig => (String,sbt.Configuration)(String, sbt.Configuration)(sbt.Configurationconfig.=> Stringname, sbt.Configurationconfig)).=> Seq[(String, sbt.Configuration)]toSeq: _*).=> Iterator[sbt.Configuration]values.=> List[sbt.Configuration]toList: _*)
}
/** Interface between Ivy logging and sbt logging. */
private final class class IvyLogger extends java.lang.Object with org.apache.ivy.util.MessageLogger with ScalaObjectIvyLogger(sbt.Loggerlog: sbt.LoggerLogger) extends org.apache.ivy.util.MessageLoggerMessageLogger
{
	private var BooleanprogressEnabled = Boolean(false)false
	
	def (String,Int)Unitlog(Stringmsg: StringString, Intlevel: IntInt)
	{
		import Message.{MSG_DEBUG, MSG_VERBOSE, MSG_INFO, MSG_WARN, MSG_ERR}
		Intlevel Unitmatch
		{
			Unitcase Int(4)MSG_DEBUG | Int(3)MSG_VERBOSE => (String)Unitdebug(Stringmsg)
			Unitcase Int(2)MSG_INFO => (String)Unitinfo(Stringmsg)
			Unitcase Int(1)MSG_WARN => (String)Unitwarn(Stringmsg)
			Unitcase Int(0)MSG_ERR => (String)Uniterror(Stringmsg)
		}
	}
	def (String,Int)Unitrawlog(Stringmsg: StringString, Intlevel: IntInt)
	{
		(String,Int)Unitlog(Stringmsg, Intlevel)
	}
	import Level.{Debug, Info, Warn, Error}
	def (String)Unitdebug(Stringmsg: StringString) = (String,sbt.Level.Value)UnitlogImpl(Stringmsg, => sbt.Level.ValueDebug)
	def (String)Unitverbose(Stringmsg: StringString) = (String)Unitdebug(Stringmsg)
	def (String)Unitdeprecated(Stringmsg: StringString) = (String)Unitwarn(Stringmsg)
	def (String)Unitinfo(Stringmsg: StringString) = (String,sbt.Level.Value)UnitlogImpl(Stringmsg, => sbt.Level.ValueInfo)
	def (String)Unitrawinfo(Stringmsg: StringString) = (String)Unitinfo(Stringmsg)
	def (String)Unitwarn(Stringmsg: StringString) = (String,sbt.Level.Value)UnitlogImpl(Stringmsg, => sbt.Level.ValueWarn)
	def (String)Uniterror(Stringmsg: StringString) = (String,sbt.Level.Value)UnitlogImpl(Stringmsg, => sbt.Level.ValueError)
	
	private def (String,sbt.Level.Value)UnitlogImpl(Stringmsg: StringString, sbt.Level.Valuelevel: Level.sbt.Level.ValueValue) = sbt.Loggerlog.(sbt.Level.Value,=> String)Unitlog(sbt.Level.Valuelevel, Stringmsg)
	
	private def => java.util.List[T forSome { type T }]emptyList = java.util.object java.util.CollectionsCollections.()java.util.List[T forSome { type T }]emptyList[T T forSome { type T }forSome { type T}]
	def ()java.util.List[T forSome { type T }]getProblems = => java.util.List[T forSome { type T }]emptyList
	def ()java.util.List[T forSome { type T }]getWarns = => java.util.List[T forSome { type T }]emptyList
	def ()java.util.List[T forSome { type T }]getErrors = => java.util.List[T forSome { type T }]emptyList

	def ()UnitclearProblems = Unit()
	def ()UnitsumupProblems = Unit()
	def ()Unitprogress = Unit()
	def ()UnitendProgress = Unit()

	def (String)UnitendProgress(Stringmsg: StringString) = (String)Unitinfo(Stringmsg)
	def ()BooleanisShowProgress = Boolean(false)false
	def (Boolean)UnitsetShowProgress(Booleanprogress: BooleanBoolean) Unit{}
}