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

import java.io.File
import java.net.{URL, URLClassLoader}
import scala.xml.NodeSeq

object object sbt.JettyRunJettyRun extends sbt.ExitHookExitHook
{
	object sbt.ExitHooksExitHooks.(sbt.ExitHook)Unitregister(this)
	
	def => java.lang.Stringname = java.lang.String("jetty-shutdown")"jetty-shutdown"
	def ()UnitrunBeforeExiting() { ()Unitstop() }
	private var Option[sbt.Stoppable]running: Option[sbt.Stoppable]Option[Stoppable] = object NoneNone
	private def (sbt.Stoppable)Unitstarted(sbt.Stoppables: sbt.StoppableStoppable) { (Option[sbt.Stoppable])Unitrunning = (sbt.Stoppable)Some[sbt.Stoppable]Some(sbt.Stoppables) }
	def ()Unitstop()
	{
		(Unit)Unitsynchronized
		{
			=> Option[sbt.Stoppable]running.((sbt.Stoppable) => Unit)Unitforeach(sbt.Stoppable_.()Unitstop())
			(Option[sbt.Stoppable])Unitrunning = object NoneNone
		}
	}
	def (Iterable[sbt.Path],String,sbt.Path,String,scala.xml.NodeSeq,Seq[java.io.File],sbt.Logger)Option[String]apply(Iterable[sbt.Path]classpath: Iterable[sbt.Path]Iterable[Path], StringclasspathName: StringString, sbt.Pathwar: sbt.PathPath, StringdefaultContextPath: StringString, scala.xml.NodeSeqjettyConfigurationXML: scala.xml.NodeSeqNodeSeq,
		Seq[java.io.File]jettyConfigurationFiles: Seq[java.io.File]Seq[File], sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
			(String,sbt.JettyRunConfiguration,sbt.Logger)Option[String]run(StringclasspathName, sbt.JettyRunConfigurationnew sbt.JettyRunConfigurationJettyRunConfiguration(sbt.Pathwar, StringdefaultContextPath, scala.xml.NodeSeqjettyConfigurationXML,
				Seq[java.io.File]jettyConfigurationFiles, object NilNil, Int(0)0, (Iterable[sbt.Path])Seq[java.net.URL]toURLs(Iterable[sbt.Path]classpath)), sbt.Loggerlog)
	def (Iterable[sbt.Path],String,sbt.Path,String,Seq[java.io.File],Int,sbt.Logger)Option[String]apply(Iterable[sbt.Path]classpath: Iterable[sbt.Path]Iterable[Path], StringclasspathName: StringString, sbt.Pathwar: sbt.PathPath, StringdefaultContextPath: StringString, Seq[java.io.File]scanDirectories: Seq[java.io.File]Seq[File],
		IntscanPeriod: IntInt, sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
			(String,sbt.JettyRunConfiguration,sbt.Logger)Option[String]run(StringclasspathName, sbt.JettyRunConfigurationnew sbt.JettyRunConfigurationJettyRunConfiguration(sbt.Pathwar, StringdefaultContextPath, object scala.xml.NodeSeqNodeSeq.=> <refinement> extends scala.xml.NodeSeqEmpty, object NilNil, Seq[java.io.File]scanDirectories, IntscanPeriod, (Iterable[sbt.Path])Seq[java.net.URL]toURLs(Iterable[sbt.Path]classpath)), sbt.Loggerlog)
	private def (Iterable[sbt.Path])Seq[java.net.URL]toURLs(Iterable[sbt.Path]paths: Iterable[sbt.Path]Iterable[Path]) = Iterable[sbt.Path]paths.((sbt.Path) => java.net.URL)Iterable[java.net.URL]map(sbt.Path_.=> java.net.URLasURL).=> Seq[java.net.URL]toSeq
	private def (String,sbt.JettyRunConfiguration,sbt.Logger)Option[String]run(StringclasspathName: StringString, sbt.JettyRunConfigurationconfiguration: sbt.JettyRunConfigurationJettyRunConfiguration, sbt.Loggerlog: sbt.LoggerLogger): Option[String]Option[String] =
		(Option[String])Option[String]synchronized
		{
			import configuration._
			def ()sbt.StoppablerunJetty() =
			{
				val java.lang.ClassLoaderbaseLoader = this.()java.lang.Class[_ <: java.lang.Object]getClass.()java.lang.ClassLoadergetClassLoader
				val java.lang.ClassLoaderloader: java.lang.ClassLoaderClassLoader = (Array[java.net.URL],java.lang.ClassLoader,Iterable[String])sbt.FilteredLoadernew sbt.FilteredLoaderFilteredLoader(=> Seq[java.net.URL]classpathURLs.Array[java.net.URL]toArray, java.lang.ClassLoaderbaseLoader, java.lang.String("org.mortbay.")"org.mortbay." (java.lang.String)List[java.lang.String]:: java.lang.String("javax.servlet.")"javax.servlet." (java.lang.String)List[java.lang.String]:: object NilNil)
				val sbt.LazyFrameworkLoaderlazyLoader = sbt.LazyFrameworkLoadernew sbt.LazyFrameworkLoaderLazyFrameworkLoader(=> java.lang.StringimplClassName, (java.net.URL*)Array[java.net.URL]Array(object sbt.FileUtilitiesFileUtilities.=> java.io.FilesbtJar.()java.net.URItoURI.()java.net.URLtoURL), java.lang.ClassLoaderloader, java.lang.ClassLoaderbaseLoader)
				val sbt.JettyRunrunner = object sbt.ModuleUtilitiesModuleUtilities.(String,java.lang.ClassLoader)java.lang.ObjectgetObject(=> java.lang.StringimplClassName, sbt.LazyFrameworkLoaderlazyLoader).sbt.JettyRunasInstanceOf[sbt.JettyRunJettyRun]
				(sbt.JettyRunConfiguration,sbt.Logger)sbt.Stoppablerunner(sbt.JettyRunConfigurationconfiguration, sbt.Loggerlog)
			}
			
			Option[String]if(=> Option[sbt.Stoppable]running.=> BooleanisDefined)
				(java.lang.String)Some[java.lang.String]Some(java.lang.String("Jetty is already running.")"Jetty is already running.")
			else
			{
				try
				{
					(sbt.Stoppable)Unitstarted(()sbt.StoppablerunJetty())
					object NoneNone
				}
				catch
				{
					Some[java.lang.String]case java.lang.NoClassDefFoundErrore: java.lang.NoClassDefFoundErrorNoClassDefFoundError => (Throwable,String,sbt.Logger)Some[java.lang.String]runError(java.lang.NoClassDefFoundErrore, java.lang.String("Jetty and its dependencies must be on the ")"Jetty and its dependencies must be on the " (Any)java.lang.String+ StringclasspathName (Any)java.lang.String+ java.lang.String(" classpath: ")" classpath: ", sbt.Loggerlog)
					Some[java.lang.String]case java.lang.Throwablee => (Throwable,String,sbt.Logger)Some[java.lang.String]runError(java.lang.Throwablee, java.lang.String("Error running Jetty: ")"Error running Jetty: ", sbt.Loggerlog)
				}
			}
		}
	private val java.lang.StringimplClassName = java.lang.String("sbt.LazyJettyRun")"sbt.LazyJettyRun"
	
	private def (Throwable,String,sbt.Logger)Some[java.lang.String]runError(Throwablee: ThrowableThrowable, StringmessageBase: StringString, sbt.Loggerlog: sbt.LoggerLogger) =
	{
		sbt.Loggerlog.(=> Throwable)Unittrace(Throwablee)
		(java.lang.String)Some[java.lang.String]Some(StringmessageBase (Any)java.lang.String+ Throwablee.()java.lang.StringtoString)
	}
}

private trait trait Stoppable extends java.lang.ObjectStoppable
{
	def ()Unitstop(): UnitUnit
}
private trait trait JettyRun extends java.lang.ObjectJettyRun
{
	def (sbt.JettyRunConfiguration,sbt.Logger)sbt.Stoppableapply(sbt.JettyRunConfigurationconfiguration: sbt.JettyRunConfigurationJettyRunConfiguration, sbt.Loggerlog: sbt.LoggerLogger): sbt.StoppableStoppable
}
private class class JettyRunConfiguration extends java.lang.Object with NotNull with ScalaObjectJettyRunConfiguration(val sbt.Pathwar: sbt.PathPath, val StringdefaultContextPath: StringString, val scala.xml.NodeSeqjettyConfigurationXML: scala.xml.NodeSeqNodeSeq, val Seq[java.io.File]jettyConfigurationFiles: Seq[java.io.File]Seq[File],
		val Seq[java.io.File]scanDirectories: Seq[java.io.File]Seq[File], val IntscanInterval: IntInt, val Seq[java.net.URL]classpathURLs: Seq[java.net.URL]Seq[URL]) extends NotNullNotNull

/* This class starts Jetty.
* NOTE: DO NOT actively use this class.  You will see NoClassDefFoundErrors if you fail
*  to do so.Only use its name in JettyRun for reflective loading.  This allows using
*  the Jetty libraries provided on the project classpath instead of requiring them to be
*  available on sbt's classpath at startup.
*/
private object object sbt.LazyJettyRunLazyJettyRun extends sbt.JettyRunJettyRun
{
	import org.mortbay.jetty.{Handler, Server}
	import org.mortbay.jetty.nio.SelectChannelConnector
	import org.mortbay.jetty.webapp.WebAppContext
	import org.mortbay.log.Log
	import org.mortbay.util.Scanner
	import org.mortbay.xml.XmlConfiguration
	
	import java.lang.ref.{Reference, WeakReference}
	
	def (sbt.JettyRunConfiguration,sbt.Logger)sbt.Stoppableapply(sbt.JettyRunConfigurationconfiguration: sbt.JettyRunConfigurationJettyRunConfiguration, sbt.Loggerlog: sbt.LoggerLogger): sbt.StoppableStoppable =
	{
		import configuration._
		val org.mortbay.log.LoggeroldLog = object org.mortbay.log.LogLog.()org.mortbay.log.LoggergetLog
		object org.mortbay.log.LogLog.(org.mortbay.log.Logger)UnitsetLog(sbt.LazyJettyRun.JettyLoggernew sbt.LazyJettyRun.JettyLoggerJettyLogger(sbt.Loggerlog))
		val org.mortbay.jetty.Serverserver = org.mortbay.jetty.Servernew org.mortbay.jetty.ServerServer
		val BooleanuseDefaults = => scala.xml.NodeSeqjettyConfigurationXML.=> BooleanisEmpty (Boolean)Boolean&& => Seq[java.io.File]jettyConfigurationFiles.=> BooleanisEmpty
		
		val Option[java.lang.Object with org.mortbay.util.Scanner.BulkListener]listener =
			Option[java.lang.Object with org.mortbay.util.Scanner.BulkListener{ ... }]if(BooleanuseDefaults)
			{
				(org.mortbay.jetty.Server)UnitconfigureDefaultConnector(org.mortbay.jetty.Serverserver)
				def => java.net.URLClassLoadercreateLoader = java.net.URLClassLoadernew java.net.URLClassLoaderURLClassLoader(=> Seq[java.net.URL]classpathURLs.Array[java.net.URL]toArray, this.()java.lang.Class[_ <: java.lang.Object]getClass.()java.lang.ClassLoadergetClassLoader)
				val org.mortbay.jetty.webapp.WebAppContextwebapp = (java.lang.String,java.lang.String)org.mortbay.jetty.webapp.WebAppContextnew org.mortbay.jetty.webapp.WebAppContextWebAppContext(=> sbt.Pathwar.=> java.io.FileasFile.()java.lang.StringgetCanonicalPath, => StringdefaultContextPath)
				org.mortbay.jetty.webapp.WebAppContextwebapp.(java.lang.ClassLoader)UnitsetClassLoader(=> java.net.URLClassLoadercreateLoader)
				org.mortbay.jetty.Serverserver.(org.mortbay.jetty.Handler)UnitsetHandler(org.mortbay.jetty.webapp.WebAppContextwebapp)
				
				(java.lang.Object with org.mortbay.util.Scanner.BulkListener{ ... })Some[java.lang.Object with org.mortbay.util.Scanner.BulkListener{ ... }]Some(template $anon extends java.lang.Object with org.mortbay.util.Scanner.BulkListenernew Scanner.org.mortbay.util.Scanner.BulkListenerBulkListener {
					def (java.util.List[_])UnitfilesChanged(java.util.List[_]files: java.util.List[_]java.util.List[_]) {
						(org.mortbay.jetty.Server,=> Unit,sbt.Logger)Unitreload(org.mortbay.jetty.Serverserver, org.mortbay.jetty.webapp.WebAppContextwebapp.(java.lang.ClassLoader)UnitsetClassLoader(=> java.net.URLClassLoadercreateLoader), sbt.Loggerlog)
					}
				})
			}
			else
			{
				for(((scala.xml.Node) => Unit)Unitx <- => scala.xml.NodeSeqjettyConfigurationXML)
					((java.lang.String)org.mortbay.xml.XmlConfigurationnew org.mortbay.xml.XmlConfigurationXmlConfiguration(scala.xml.Nodex.()StringtoString)).(Any)Unitconfigure(org.mortbay.jetty.Serverserver)
				for(((java.io.File) => Unit)Unitfile <- => Seq[java.io.File]jettyConfigurationFiles)
					(org.mortbay.xml.XmlConfigurationnew org.mortbay.xml.XmlConfigurationXmlConfiguration(java.io.Filefile.()java.net.URItoURI.()java.net.URLtoURL)).(Any)Unitconfigure(org.mortbay.jetty.Serverserver)
				object NoneNone
			}
		
		def ()Option[java.lang.ref.WeakReference[org.mortbay.util.Scanner]]configureScanner() =
		{
			Option[java.lang.ref.WeakReference[org.mortbay.util.Scanner]]if(Option[java.lang.Object with org.mortbay.util.Scanner.BulkListener]listener.=> BooleanisEmpty (Boolean)Boolean|| => Seq[java.io.File]scanDirectories.=> BooleanisEmpty)
				object NoneNone
			else
			{
				sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Scanning for changes to: ")"Scanning for changes to: " (Any)java.lang.String+ => Seq[java.io.File]scanDirectories.(String)StringmkString(java.lang.String(", ")", "))
				val org.mortbay.util.Scannerscanner = org.mortbay.util.Scannernew org.mortbay.util.ScannerScanner
				import scala.collection.jcl.Conversions._
				val java.util.ArrayList[java.io.File]list = ()java.util.ArrayList[java.io.File]new java.util.java.util.ArrayList[java.io.File]ArrayList[File]
				=> Seq[java.io.File]scanDirectories.((java.io.File) => Unit)Unitforeach(java.io.Filex => java.util.ArrayList[java.io.File]list.(java.io.File)Booleanadd(java.io.Filex))
				org.mortbay.util.Scannerscanner.(java.util.List[_])UnitsetScanDirs(java.util.ArrayList[java.io.File]list)
				org.mortbay.util.Scannerscanner.(Boolean)UnitsetRecursive(Boolean(true)true)
				org.mortbay.util.Scannerscanner.(Int)UnitsetScanInterval(=> IntscanInterval)
				org.mortbay.util.Scannerscanner.(Boolean)UnitsetReportExistingFilesOnStartup(Boolean(false)false)
				org.mortbay.util.Scannerscanner.(org.mortbay.util.Scanner.Listener)UnitaddListener(Option[java.lang.Object with org.mortbay.util.Scanner.BulkListener]listener.=> <refinement> extends java.lang.Object with org.mortbay.util.Scanner.BulkListenerget)
				org.mortbay.util.Scannerscanner.()Unitstart()
				(java.lang.ref.WeakReference[org.mortbay.util.Scanner])Some[java.lang.ref.WeakReference[org.mortbay.util.Scanner]]Some(java.lang.ref.WeakReference[org.mortbay.util.Scanner]new java.lang.ref.WeakReference[org.mortbay.util.Scanner]WeakReference(org.mortbay.util.Scannerscanner))
			}
		}
		
		try
		{
			org.mortbay.jetty.Serverserver.()Unitstart()
			sbt.LazyJettyRun.StopServernew sbt.LazyJettyRun.StopServerStopServer(java.lang.ref.WeakReference[org.mortbay.jetty.Server]new java.lang.ref.WeakReference[org.mortbay.jetty.Server]WeakReference(org.mortbay.jetty.Serverserver), ()Option[java.lang.ref.WeakReference[org.mortbay.util.Scanner]]configureScanner(), org.mortbay.log.LoggeroldLog)
		}
		catch { Nothingcase java.lang.Throwablee => org.mortbay.jetty.Serverserver.()Unitstop(); Nothingthrow java.lang.Throwablee }
	}
	private def (org.mortbay.jetty.Server)UnitconfigureDefaultConnector(org.mortbay.jetty.Serverserver: org.mortbay.jetty.ServerServer)
	{
		val org.mortbay.jetty.nio.SelectChannelConnectordefaultConnector = org.mortbay.jetty.nio.SelectChannelConnectornew org.mortbay.jetty.nio.SelectChannelConnectorSelectChannelConnector
		org.mortbay.jetty.nio.SelectChannelConnectordefaultConnector.(Int)UnitsetPort(Int(8080)8080)
		org.mortbay.jetty.nio.SelectChannelConnectordefaultConnector.(Int)UnitsetMaxIdleTime(Int(30000)30000)
		org.mortbay.jetty.Serverserver.(org.mortbay.jetty.Connector)UnitaddConnector(org.mortbay.jetty.nio.SelectChannelConnectordefaultConnector)
	}
	private class class StopServer extends java.lang.Object with sbt.Stoppable with ScalaObjectStopServer(java.lang.ref.Reference[org.mortbay.jetty.Server]serverReference: java.lang.ref.Reference[org.mortbay.jetty.Server]Reference[Server], Option[java.lang.ref.Reference[org.mortbay.util.Scanner]]scannerReferenceOpt: Option[java.lang.ref.Reference[org.mortbay.util.Scanner]]Option[Reference[Scanner]], org.mortbay.log.LoggeroldLog: org.mortbay.log.org.mortbay.log.LoggerLogger) extends sbt.StoppableStoppable
	{
		def ()Unitstop()
		{
			val org.mortbay.jetty.Serverserver = java.lang.ref.Reference[org.mortbay.jetty.Server]serverReference.()org.mortbay.jetty.Serverget
			Unitif(org.mortbay.jetty.Serverserver (AnyRef)Boolean!= Null(null)null)
				org.mortbay.jetty.Serverserver.()Unitstop()
			for(((java.lang.ref.Reference[org.mortbay.util.Scanner]) => Unit)UnitscannerReference <- Option[java.lang.ref.Reference[org.mortbay.util.Scanner]]scannerReferenceOpt)
			{
				val org.mortbay.util.Scannerscanner = java.lang.ref.Reference[org.mortbay.util.Scanner]scannerReference.()org.mortbay.util.Scannerget
				Unitif(org.mortbay.util.Scannerscanner (AnyRef)Boolean!= Null(null)null)
					org.mortbay.util.Scannerscanner.()Unitstop()
			}
			object org.mortbay.log.LogLog.(org.mortbay.log.Logger)UnitsetLog(org.mortbay.log.LoggeroldLog)
		}
	}
	private def (org.mortbay.jetty.Server,=> Unit,sbt.Logger)Unitreload(org.mortbay.jetty.Serverserver: org.mortbay.jetty.ServerServer, => Unitreconfigure: => Unit, sbt.Loggerlog: sbt.LoggerLogger)
	{
		object sbt.JettyRunJettyRun.(Unit)Unitsynchronized
		{
			sbt.Loggerlog.(=> String)Unitinfo(java.lang.String("Reloading web application...")"Reloading web application...")
			val List[org.mortbay.jetty.Handler]handlers = (Array[org.mortbay.jetty.Handler],org.mortbay.jetty.Handler)List[org.mortbay.jetty.Handler]wrapNull(org.mortbay.jetty.Serverserver.()Array[org.mortbay.jetty.Handler]getHandlers, org.mortbay.jetty.Serverserver.()org.mortbay.jetty.HandlergetHandler)
			sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Stopping handlers: ")"Stopping handlers: " (Any)java.lang.String+ List[org.mortbay.jetty.Handler]handlers.(String)StringmkString(java.lang.String(", ")", "))
			List[org.mortbay.jetty.Handler]handlers.((org.mortbay.jetty.Handler) => Unit)Unitforeach(org.mortbay.jetty.Handler_.()Unitstop)
			sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Reconfiguring...")"Reconfiguring...")
			=> Unitreconfigure
			sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Restarting handlers: ")"Restarting handlers: " (Any)java.lang.String+ List[org.mortbay.jetty.Handler]handlers.(String)StringmkString(java.lang.String(", ")", "))
			List[org.mortbay.jetty.Handler]handlers.((org.mortbay.jetty.Handler) => Unit)Unitforeach(org.mortbay.jetty.Handler_.()Unitstart)
			sbt.Loggerlog.(=> String)Unitinfo(java.lang.String("Reload complete.")"Reload complete.")
		}
	}
	private def (Array[org.mortbay.jetty.Handler],org.mortbay.jetty.Handler)List[org.mortbay.jetty.Handler]wrapNull(Array[org.mortbay.jetty.Handler]a: Array[org.mortbay.jetty.Handler]Array[Handler], org.mortbay.jetty.Handlerb: org.mortbay.jetty.HandlerHandler) =
		(Array[org.mortbay.jetty.Handler],org.mortbay.jetty.Handler)(Array[org.mortbay.jetty.Handler], org.mortbay.jetty.Handler)(Array[org.mortbay.jetty.Handler]a, org.mortbay.jetty.Handlerb) List[org.mortbay.jetty.Handler]match
		{
			Nil.typecase (Null(null)null, Null(null)null) => object NilNil
			List[org.mortbay.jetty.Handler]case (Null(null)null, org.mortbay.jetty.HandlernotB) => org.mortbay.jetty.HandlernotB (org.mortbay.jetty.Handler)List[org.mortbay.jetty.Handler]:: object NilNil
			List[org.mortbay.jetty.Handler]case (Array[org.mortbay.jetty.Handler]notA, Null(null)null) => Array[org.mortbay.jetty.Handler]notA.=> List[org.mortbay.jetty.Handler]toList
			List[org.mortbay.jetty.Handler]case (Array[org.mortbay.jetty.Handler]notA, org.mortbay.jetty.HandlernotB) => org.mortbay.jetty.HandlernotB (org.mortbay.jetty.Handler)List[org.mortbay.jetty.Handler]:: Array[org.mortbay.jetty.Handler]notA.=> List[org.mortbay.jetty.Handler]toList
		}
	private class class JettyLogger extends java.lang.Object with org.mortbay.log.Logger with ScalaObjectJettyLogger(sbt.Loggerdelegate: sbt.LoggerLogger) extends org.mortbay.log.org.mortbay.log.LoggerLogger
	{
		def ()BooleanisDebugEnabled = sbt.Loggerdelegate.(sbt.Level.Value)BooleanatLevel(object sbt.LevelLevel.=> sbt.Level.ValueDebug)
		def (Boolean)UnitsetDebugEnabled(Booleanenabled: BooleanBoolean) = sbt.Loggerdelegate.(sbt.Level.Value)UnitsetLevel(sbt.Level.Valueif(Booleanenabled) object sbt.LevelLevel.=> sbt.Level.ValueDebug else object sbt.LevelLevel.=> sbt.Level.ValueInfo)
	
		def (String)sbt.LazyJettyRun.JettyLoggergetLogger(Stringname: StringString) = sbt.LazyJettyRun.JettyLoggerthis
		def (String,AnyRef,AnyRef)Unitinfo(Stringmsg: StringString, AnyRefarg0: AnyRefAnyRef, AnyRefarg1: AnyRefAnyRef) { sbt.Loggerdelegate.(=> String)Unitinfo((String,AnyRef,AnyRef)java.lang.Stringformat(Stringmsg, AnyRefarg0, AnyRefarg1)) }
		def (String,AnyRef,AnyRef)Unitdebug(Stringmsg: StringString, AnyRefarg0: AnyRefAnyRef, AnyRefarg1: AnyRefAnyRef) { sbt.Loggerdelegate.(=> String)Unitdebug((String,AnyRef,AnyRef)java.lang.Stringformat(Stringmsg, AnyRefarg0, AnyRefarg1)) }
		def (String,AnyRef,AnyRef)Unitwarn(Stringmsg: StringString, AnyRefarg0: AnyRefAnyRef, AnyRefarg1: AnyRefAnyRef) { sbt.Loggerdelegate.(=> String)Unitwarn((String,AnyRef,AnyRef)java.lang.Stringformat(Stringmsg, AnyRefarg0, AnyRefarg1)) }
		def (String,Throwable)Unitwarn(Stringmsg: StringString, Throwableth: ThrowableThrowable)
		{
			sbt.Loggerdelegate.(=> String)Unitwarn(Stringmsg)
			sbt.Loggerdelegate.(=> Throwable)Unittrace(Throwableth)
		}
		def (String,Throwable)Unitdebug(Stringmsg: StringString, Throwableth: ThrowableThrowable)
		{
			sbt.Loggerdelegate.(=> String)Unitdebug(Stringmsg)
			sbt.Loggerdelegate.(=> Throwable)Unittrace(Throwableth)
		}
		private def (String,AnyRef,AnyRef)java.lang.Stringformat(Stringmsg: StringString, AnyRefarg0: AnyRefAnyRef, AnyRefarg1: AnyRefAnyRef) =
		{
			def (AnyRef)java.lang.StringtoString(AnyRefarg: AnyRefAnyRef) = java.lang.Stringif(AnyRefarg (AnyRef)Boolean== Null(null)null) java.lang.String("")"" else AnyRefarg.()java.lang.StringtoString
			val Array[java.lang.String]pieces = Stringmsg.(java.lang.String,Int)Array[java.lang.String]split(java.lang.String("\{\}")"""\{\}""", Int(3)3)
			java.lang.Stringif(Array[java.lang.String]pieces.=> Intlength (Int)Boolean== Int(1)1)
				(Int)java.lang.Stringpieces(Int(0)0)
			else
			{
				val java.lang.Stringbase = (Int)java.lang.Stringpieces(Int(0)0) (Any)java.lang.String+ (AnyRef)java.lang.StringtoString(AnyRefarg0) (Any)java.lang.String+ (Int)java.lang.Stringpieces(Int(1)1)
				java.lang.Stringif(Array[java.lang.String]pieces.=> Intlength (Int)Boolean== Int(2)2)
					java.lang.Stringbase
				else
					java.lang.Stringbase (Any)java.lang.String+ (AnyRef)java.lang.StringtoString(AnyRefarg1) (Any)java.lang.String+ (Int)java.lang.Stringpieces(Int(2)2)
			}
		}
	}
}