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

import scala.collection.jcl.WeakHashMap
import scala.collection.mutable.{Buffer, ListBuffer}

sealed trait trait LogEvent extends java.lang.Object with NotNullLogEvent extends NotNullNotNull
final class class Success extends java.lang.Object with sbt.LogEvent with ScalaObjectSuccess(val Stringmsg: StringString) extends sbt.LogEventLogEvent
final class class Log extends java.lang.Object with sbt.LogEvent with ScalaObjectLog(val sbt.Level.Valuelevel: Level.sbt.Level.ValueValue, val Stringmsg: StringString) extends sbt.LogEventLogEvent
final class class Trace extends java.lang.Object with sbt.LogEvent with ScalaObjectTrace(val Throwableexception: ThrowableThrowable) extends sbt.LogEventLogEvent
final class class SetLevel extends java.lang.Object with sbt.LogEvent with ScalaObjectSetLevel(val sbt.Level.ValuenewLevel: Level.sbt.Level.ValueValue) extends sbt.LogEventLogEvent
final class class SetTrace extends java.lang.Object with sbt.LogEvent with ScalaObjectSetTrace(val Booleanenabled: BooleanBoolean) extends sbt.LogEventLogEvent
final class class ControlEvent extends java.lang.Object with sbt.LogEvent with ScalaObjectControlEvent(val sbt.ControlEvent.Valueevent: ControlEvent.sbt.ControlEvent.ValueValue, val Stringmsg: StringString) extends sbt.LogEventLogEvent

object object sbt.ControlEventControlEvent extends EnumerationEnumeration
{
	val sbt.ControlEvent.ValueStart, sbt.ControlEvent.ValueHeader, sbt.ControlEvent.ValueFinish = => sbt.ControlEvent.ValueValue
}

abstract class class Logger extends java.lang.Object with NotNull with ScalaObjectLogger extends NotNullNotNull
{
	def => sbt.Level.ValuegetLevel: Level.sbt.Level.ValueValue
	def (sbt.Level.Value)UnitsetLevel(sbt.Level.ValuenewLevel: Level.sbt.Level.ValueValue)
	def (Boolean)UnitenableTrace(Booleanflag: BooleanBoolean)
	def => BooleantraceEnabled: BooleanBoolean
	
	def (sbt.Level.Value)BooleanatLevel(sbt.Level.Valuelevel: Level.sbt.Level.ValueValue) = sbt.Level.Valuelevel.=> Intid (Int)Boolean>= => sbt.Level.ValuegetLevel.=> Intid
	def (=> Throwable)Unittrace(=> Throwablet: => Throwable): UnitUnit
	final def (=> String)Unitdebug(=> Stringmessage: => String): UnitUnit = (sbt.Level.Value,=> String)Unitlog(object sbt.LevelLevel.=> sbt.Level.ValueDebug, => Stringmessage)
	final def (=> String)Unitinfo(=> Stringmessage: => String): UnitUnit = (sbt.Level.Value,=> String)Unitlog(object sbt.LevelLevel.=> sbt.Level.ValueInfo, => Stringmessage)
	final def (=> String)Unitwarn(=> Stringmessage: => String): UnitUnit = (sbt.Level.Value,=> String)Unitlog(object sbt.LevelLevel.=> sbt.Level.ValueWarn, => Stringmessage)
	final def (=> String)Uniterror(=> Stringmessage: => String): UnitUnit = (sbt.Level.Value,=> String)Unitlog(object sbt.LevelLevel.=> sbt.Level.ValueError, => Stringmessage)
	def (=> String)Unitsuccess(=> Stringmessage: => String): UnitUnit
	def (sbt.Level.Value,=> String)Unitlog(sbt.Level.Valuelevel: Level.sbt.Level.ValueValue, => Stringmessage: => String): UnitUnit
	def (sbt.ControlEvent.Value,=> String)Unitcontrol(sbt.ControlEvent.Valueevent: ControlEvent.sbt.ControlEvent.ValueValue, => Stringmessage: => String): UnitUnit
	
	/** Use this method to ensure calls. */
	def (Seq[sbt.LogEvent])UnitlogAll(Seq[sbt.LogEvent]events: Seq[sbt.LogEvent]Seq[LogEvent]): UnitUnit
	/** Defined in terms of other methods in Logger and should not be called from them. */
	final def (sbt.LogEvent)Unitlog(sbt.LogEventevent: sbt.LogEventLogEvent)
	{
		sbt.LogEventevent Unitmatch
		{
			Unitcase sbt.Successs: sbt.SuccessSuccess => (=> String)Unitsuccess(sbt.Successs.=> Stringmsg)
			Unitcase sbt.Logl: sbt.LogLog => (sbt.Level.Value,=> String)Unitlog(sbt.Logl.=> sbt.Level.Valuelevel, sbt.Logl.=> Stringmsg)
			Unitcase sbt.Tracet: sbt.TraceTrace => (=> Throwable)Unittrace(sbt.Tracet.=> Throwableexception)
			Unitcase sbt.SetLevelsetL: sbt.SetLevelSetLevel => (sbt.Level.Value)UnitsetLevel(sbt.SetLevelsetL.=> sbt.Level.ValuenewLevel)
			Unitcase sbt.SetTracesetT: sbt.SetTraceSetTrace => (Boolean)UnitenableTrace(sbt.SetTracesetT.=> Booleanenabled)
			Unitcase sbt.ControlEventc: sbt.ControlEventControlEvent => (sbt.ControlEvent.Value,=> String)Unitcontrol(sbt.ControlEventc.=> sbt.ControlEvent.Valueevent, sbt.ControlEventc.=> Stringmsg)
		}
	}
}

/** Implements the level-setting methods of Logger.*/
abstract class class BasicLogger extends sbt.Logger with ScalaObjectBasicLogger extends sbt.LoggerLogger
{
	private var BooleantraceEnabledVar = Boolean(false)false
	private var sbt.Level.Valuelevel: Level.sbt.Level.ValueValue = object sbt.LevelLevel.=> sbt.Level.ValueInfo
	def => sbt.Level.ValuegetLevel = => sbt.Level.Valuelevel
	def (sbt.Level.Value)UnitsetLevel(sbt.Level.ValuenewLevel: Level.sbt.Level.ValueValue) { (sbt.Level.Value)Unitlevel = sbt.Level.ValuenewLevel }
	def (Boolean)UnitenableTrace(Booleanflag: BooleanBoolean) { (Boolean)UnittraceEnabledVar = Booleanflag }
	def => BooleantraceEnabled = => BooleantraceEnabledVar
}

final class class SynchronizedLogger extends sbt.Logger with ScalaObjectSynchronizedLogger(sbt.Loggerdelegate: sbt.LoggerLogger) extends sbt.LoggerLogger
{
	def => sbt.Level.ValuegetLevel = { (sbt.Level.Value)sbt.Level.Valuesynchronized { sbt.Loggerdelegate.=> sbt.Level.ValuegetLevel } }
	def (sbt.Level.Value)UnitsetLevel(sbt.Level.ValuenewLevel: Level.sbt.Level.ValueValue) { (Unit)Unitsynchronized { sbt.Loggerdelegate.(sbt.Level.Value)UnitsetLevel(sbt.Level.ValuenewLevel) } }
	def (Boolean)UnitenableTrace(Booleanenabled: BooleanBoolean) { (Unit)Unitsynchronized { sbt.Loggerdelegate.(Boolean)UnitenableTrace(Booleanenabled) } }
	def => BooleantraceEnabled: BooleanBoolean = { (Boolean)Booleansynchronized { sbt.Loggerdelegate.=> BooleantraceEnabled } }
	
	def (=> Throwable)Unittrace(=> Throwablet: => Throwable) { (Unit)Unitsynchronized { sbt.Loggerdelegate.(=> Throwable)Unittrace(=> Throwablet) } }
	def (sbt.Level.Value,=> String)Unitlog(sbt.Level.Valuelevel: Level.sbt.Level.ValueValue, => Stringmessage: => String) { (Unit)Unitsynchronized { sbt.Loggerdelegate.(sbt.Level.Value,=> String)Unitlog(sbt.Level.Valuelevel, => Stringmessage) } }
	def (=> String)Unitsuccess(=> Stringmessage: => String) { (Unit)Unitsynchronized { sbt.Loggerdelegate.(=> String)Unitsuccess(=> Stringmessage) } }
	def (sbt.ControlEvent.Value,=> String)Unitcontrol(sbt.ControlEvent.Valueevent: ControlEvent.sbt.ControlEvent.ValueValue, => Stringmessage: => String) { (Unit)Unitsynchronized { sbt.Loggerdelegate.(sbt.ControlEvent.Value,=> String)Unitcontrol(sbt.ControlEvent.Valueevent, => Stringmessage) } }
	def (Seq[sbt.LogEvent])UnitlogAll(Seq[sbt.LogEvent]events: Seq[sbt.LogEvent]Seq[LogEvent]) { (Unit)Unitsynchronized { sbt.Loggerdelegate.(Seq[sbt.LogEvent])UnitlogAll(Seq[sbt.LogEvent]events) } }
}

final class class MultiLogger extends sbt.BasicLogger with ScalaObjectMultiLogger(List[sbt.Logger]delegates: List[sbt.Logger]List[Logger]) extends sbt.BasicLoggerBasicLogger
{
	override def (sbt.Level.Value)UnitsetLevel(sbt.Level.ValuenewLevel: Level.sbt.Level.ValueValue)
	{
		super.(sbt.Level.Value)UnitsetLevel(sbt.Level.ValuenewLevel)
		(sbt.LogEvent)Unitdispatch(sbt.SetLevelnew sbt.SetLevelSetLevel(sbt.Level.ValuenewLevel))
	}
	override def (Boolean)UnitenableTrace(Booleanenabled: BooleanBoolean)
	{
		super.(Boolean)UnitenableTrace(Booleanenabled)
		(sbt.LogEvent)Unitdispatch(sbt.SetTracenew sbt.SetTraceSetTrace(Booleanenabled))
	}
	def (=> Throwable)Unittrace(=> Throwablet: => Throwable) { (sbt.LogEvent)Unitdispatch(sbt.Tracenew sbt.TraceTrace(=> Throwablet)) }
	def (sbt.Level.Value,=> String)Unitlog(sbt.Level.Valuelevel: Level.sbt.Level.ValueValue, => Stringmessage: => String) { (sbt.LogEvent)Unitdispatch(sbt.Lognew sbt.LogLog(sbt.Level.Valuelevel, => Stringmessage)) }
	def (=> String)Unitsuccess(=> Stringmessage: => String) { (sbt.LogEvent)Unitdispatch(sbt.Successnew sbt.SuccessSuccess(=> Stringmessage)) }
	def (Seq[sbt.LogEvent])UnitlogAll(Seq[sbt.LogEvent]events: Seq[sbt.LogEvent]Seq[LogEvent]) { List[sbt.Logger]delegates.((sbt.Logger) => Unit)Unitforeach(sbt.Logger_.(Seq[sbt.LogEvent])UnitlogAll(Seq[sbt.LogEvent]events)) }
	def (sbt.ControlEvent.Value,=> String)Unitcontrol(sbt.ControlEvent.Valueevent: ControlEvent.sbt.ControlEvent.ValueValue, => Stringmessage: => String) { List[sbt.Logger]delegates.((sbt.Logger) => Unit)Unitforeach(sbt.Logger_.(sbt.ControlEvent.Value,=> String)Unitcontrol(sbt.ControlEvent.Valueevent, => Stringmessage)) }
	private def (sbt.LogEvent)Unitdispatch(sbt.LogEventevent: sbt.LogEventLogEvent) { List[sbt.Logger]delegates.((sbt.Logger) => Unit)Unitforeach(sbt.Logger_.(sbt.LogEvent)Unitlog(sbt.LogEventevent)) }
}

/** A logger that can buffer the logging done on it by currently executing actor and
* then can flush the buffer to the delegate logger provided in the constructor.  Use
* 'startRecording' to start buffering and then 'play' from to flush the buffer for the
* current actor to the backing logger.  The logging level set at the
* time a message is originally logged is used, not the level at the time 'play' is
* called.
*
* This class assumes that it is the only client of the delegate logger.
*
* This logger is thread-safe.
* */
final class class BufferedLogger extends sbt.Logger with ScalaObjectBufferedLogger(sbt.Loggerdelegate: sbt.LoggerLogger) extends sbt.LoggerLogger
{
	import scala.actors.Actor
	private[this] val scala.collection.jcl.WeakHashMap[scala.actors.Actor,scala.collection.mutable.Buffer[sbt.LogEvent]]buffers = ()scala.collection.jcl.WeakHashMap[scala.actors.Actor,scala.collection.mutable.Buffer[sbt.LogEvent]]new scala.collection.jcl.WeakHashMap[scala.actors.Actor,scala.collection.mutable.Buffer[sbt.LogEvent]]WeakHashMap[Actor, Buffer[LogEvent]]
	/* The recording depth part is to enable a weak nesting of recording calls.  When recording is
	*  nested (recordingDepth >= 2), calls to play/playAll add the buffers for actors to the serial buffer
	*  (no actor) and calls to clear/clearAll clear actor buffers only. */
	private[this] def => Booleanrecording = IntrecordingDepth (Int)Boolean> Int(0)0
	private[this] var IntrecordingDepth = Int(0)0
	
	private[this] def (scala.actors.Actor)scala.collection.mutable.Buffer[sbt.LogEvent]bufferForActor(scala.actors.Actora: scala.actors.ActorActor) = scala.collection.jcl.WeakHashMap[scala.actors.Actor,scala.collection.mutable.Buffer[sbt.LogEvent]]buffers.(scala.actors.Actor,=> scala.collection.mutable.Buffer[sbt.LogEvent])scala.collection.mutable.Buffer[sbt.LogEvent]getOrElseUpdate(scala.actors.Actora, scala.collection.mutable.ListBuffer[sbt.LogEvent]new scala.collection.mutable.ListBuffer[sbt.LogEvent]ListBuffer[LogEvent])
	private[this] def => scala.collection.mutable.Buffer[sbt.LogEvent]buffer = (scala.actors.Actor)scala.collection.mutable.Buffer[sbt.LogEvent]bufferForActor(object scala.actors.ActorActor.=> scala.actors.Actorself)
	private[this] def => scala.collection.mutable.Buffer[sbt.LogEvent]serialBuffer = (scala.actors.Actor)scala.collection.mutable.Buffer[sbt.LogEvent]bufferForActor(Null(null)null)

	private[this] def => BooleaninActor = object scala.actors.ActorActor.=> scala.actors.Actorself (AnyRef)Boolean!= Null(null)null
	
	/** Enables buffering. */
	def ()UnitstartRecording() { (Unit)Unitsynchronized { IntrecordingDepth (Int)Int+= Int(1)1 } }
	/** Flushes the buffer to the delegate logger for the current actor.  This method calls logAll on the delegate
	* so that the messages are written consecutively. The buffer is cleared in the process. */
	def ()Unitplay(): UnitUnit =
 		(Unit)Unitsynchronized
		{
			Unitif(IntrecordingDepth (Int)Boolean== Int(1)1)
				sbt.Loggerdelegate.(Seq[sbt.LogEvent])UnitlogAll(=> scala.collection.mutable.Buffer[sbt.LogEvent]buffer.=> Seq[sbt.LogEvent]readOnly)
			else Unitif(IntrecordingDepth (Int)Boolean> Int(1)1 (Boolean)Boolean&& => BooleaninActor)
				=> scala.collection.mutable.Buffer[sbt.LogEvent]serialBuffer (Iterable[sbt.LogEvent])Unit++= => scala.collection.mutable.Buffer[sbt.LogEvent]buffer
		}
	def ()UnitplayAll(): UnitUnit =
		(Unit)Unitsynchronized
		{
			Unitif(IntrecordingDepth (Int)Boolean== Int(1)1)
			{
				for(((scala.collection.mutable.Buffer[sbt.LogEvent]) => Unit)Unitbuffer <- scala.collection.jcl.WeakHashMap[scala.actors.Actor,scala.collection.mutable.Buffer[sbt.LogEvent]]buffers.=> Iterator[scala.collection.mutable.Buffer[sbt.LogEvent]]values)
					sbt.Loggerdelegate.(Seq[sbt.LogEvent])UnitlogAll(scala.collection.mutable.Buffer[sbt.LogEvent]buffer.=> Seq[sbt.LogEvent]readOnly)
			}
			else Unitif(IntrecordingDepth (Int)Boolean> Int(1)1)
			{
				for((((scala.actors.Actor, scala.collection.mutable.Buffer[sbt.LogEvent])) => Unit)Unit(scala.actors.Actorkey, scala.collection.mutable.Buffer[sbt.LogEvent]buffer) <- scala.collection.jcl.WeakHashMap[scala.actors.Actor,scala.collection.mutable.Buffer[sbt.LogEvent]]buffers if scala.actors.Actorkey (AnyRef)Boolean!= Null(null)null)
					=> scala.collection.mutable.Buffer[sbt.LogEvent]serialBuffer (Iterable[sbt.LogEvent])Unit++= scala.collection.mutable.Buffer[sbt.LogEvent]buffer
			}
		}
	/** Clears buffered events for the current actor.  It does not disable buffering. */
	def ()Unitclear(): UnitUnit = (Any)Anysynchronized { Anyif(IntrecordingDepth (Int)Boolean== Int(1)1 (Boolean)Boolean|| => BooleaninActor) scala.collection.jcl.WeakHashMap[scala.actors.Actor,scala.collection.mutable.Buffer[sbt.LogEvent]]buffers.(scala.actors.Actor)Option[scala.collection.mutable.Buffer[sbt.LogEvent]]removeKey(object scala.actors.ActorActor.=> scala.actors.Actorself) }
	/** Clears buffered events for all actors and disables buffering. */
	def ()Unitstop(): UnitUnit =
		(Unit)Unitsynchronized
		{
			()UnitclearAll()
			Unitif(IntrecordingDepth (Int)Boolean> Int(0)0)
				IntrecordingDepth (Int)Int-= Int(1)1
		}
	/** Clears buffered events for all actors. */
	def ()UnitclearAll(): UnitUnit =
		(Unit)Unitsynchronized
		{
			Unitif(IntrecordingDepth (Int)Boolean<= Int(1)1)
				scala.collection.jcl.WeakHashMap[scala.actors.Actor,scala.collection.mutable.Buffer[sbt.LogEvent]]buffers.()Unitclear()
			else
			{
				val scala.collection.mutable.Buffer[sbt.LogEvent]serial = => scala.collection.mutable.Buffer[sbt.LogEvent]serialBuffer
				scala.collection.jcl.WeakHashMap[scala.actors.Actor,scala.collection.mutable.Buffer[sbt.LogEvent]]buffers.()Unitclear()
				scala.collection.jcl.WeakHashMap[scala.actors.Actor,scala.collection.mutable.Buffer[sbt.LogEvent]]buffers(Null(null)null) = scala.collection.mutable.Buffer[sbt.LogEvent]serial
			}
		}
	def [T](=> T)TrunAndFlush[>: Nothing <: AnyT](=> Tf: => T): TT =
	{
		try { => Tf }
		finally { ()Unitplay();  ()Unitclear() }
	}
	
	def (sbt.Level.Value)UnitsetLevel(sbt.Level.ValuenewLevel: Level.sbt.Level.ValueValue): UnitUnit =
		(Unit)Unitsynchronized {
			Unitif(=> Booleanrecording) => scala.collection.mutable.Buffer[sbt.LogEvent]buffer (sbt.LogEvent)Unit+= sbt.SetLevelnew sbt.SetLevelSetLevel(sbt.Level.ValuenewLevel)
			sbt.Loggerdelegate.(sbt.Level.Value)UnitsetLevel(sbt.Level.ValuenewLevel)
		}
	def => sbt.Level.ValuegetLevel = (sbt.Level.Value)sbt.Level.Valuesynchronized { sbt.Loggerdelegate.=> sbt.Level.ValuegetLevel }
	def => BooleantraceEnabled = (Boolean)Booleansynchronized { sbt.Loggerdelegate.=> BooleantraceEnabled }
	def (Boolean)UnitenableTrace(Booleanflag: BooleanBoolean): UnitUnit =
		(Unit)Unitsynchronized
		{
			Unitif(=> Booleanrecording) => scala.collection.mutable.Buffer[sbt.LogEvent]buffer (sbt.LogEvent)Unit+= sbt.SetTracenew sbt.SetTraceSetTrace(Booleanflag)
			sbt.Loggerdelegate.(Boolean)UnitenableTrace(Booleanflag)
		}
	
	def (=> Throwable)Unittrace(=> Throwablet: => Throwable): UnitUnit =
		(Unit)Unitsynchronized
		{
			Unitif(=> BooleantraceEnabled)
			{
				Unitif(=> Booleanrecording) => scala.collection.mutable.Buffer[sbt.LogEvent]buffer (sbt.LogEvent)Unit+= sbt.Tracenew sbt.TraceTrace(=> Throwablet)
				else sbt.Loggerdelegate.(=> Throwable)Unittrace(=> Throwablet)
			}
		}
	def (=> String)Unitsuccess(=> Stringmessage: => String): UnitUnit =
		(Unit)Unitsynchronized
		{
			Unitif((sbt.Level.Value)BooleanatLevel(object sbt.LevelLevel.=> sbt.Level.ValueInfo))
			{
				Unitif(=> Booleanrecording)
					=> scala.collection.mutable.Buffer[sbt.LogEvent]buffer (sbt.LogEvent)Unit+= sbt.Successnew sbt.SuccessSuccess(=> Stringmessage)
				else
					sbt.Loggerdelegate.(=> String)Unitsuccess(=> Stringmessage)
			}
		}
	def (sbt.Level.Value,=> String)Unitlog(sbt.Level.Valuelevel: Level.sbt.Level.ValueValue, => Stringmessage: => String): UnitUnit =
		(Unit)Unitsynchronized
		{
			Unitif((sbt.Level.Value)BooleanatLevel(sbt.Level.Valuelevel))
			{
				Unitif(=> Booleanrecording)
					=> scala.collection.mutable.Buffer[sbt.LogEvent]buffer (sbt.LogEvent)Unit+= sbt.Lognew sbt.LogLog(sbt.Level.Valuelevel, => Stringmessage)
				else
					sbt.Loggerdelegate.(sbt.Level.Value,=> String)Unitlog(sbt.Level.Valuelevel, => Stringmessage)
			}
		}
	def (Seq[sbt.LogEvent])UnitlogAll(Seq[sbt.LogEvent]events: Seq[sbt.LogEvent]Seq[LogEvent]): UnitUnit =
		(Unit)Unitsynchronized
		{
			Unitif(=> Booleanrecording)
				=> scala.collection.mutable.Buffer[sbt.LogEvent]buffer (Iterable[sbt.LogEvent])Unit++= Seq[sbt.LogEvent]events
			else
				sbt.Loggerdelegate.(Seq[sbt.LogEvent])UnitlogAll(Seq[sbt.LogEvent]events)
		}
	def (sbt.ControlEvent.Value,=> String)Unitcontrol(sbt.ControlEvent.Valueevent: ControlEvent.sbt.ControlEvent.ValueValue, => Stringmessage: => String): UnitUnit =
		(Unit)Unitsynchronized
		{
			Unitif((sbt.Level.Value)BooleanatLevel(object sbt.LevelLevel.=> sbt.Level.ValueInfo))
			{
				Unitif(=> Booleanrecording)
					=> scala.collection.mutable.Buffer[sbt.LogEvent]buffer (sbt.LogEvent)Unit+= sbt.ControlEventnew sbt.ControlEventControlEvent(sbt.ControlEvent.Valueevent, => Stringmessage)
				else
					sbt.Loggerdelegate.(sbt.ControlEvent.Value,=> String)Unitcontrol(sbt.ControlEvent.Valueevent, => Stringmessage)
			}
		}
}

object object sbt.ConsoleLoggerConsoleLogger
{
	private def => java.lang.Stringos = object java.lang.SystemSystem.(java.lang.String)java.lang.StringgetProperty(java.lang.String("os.name")"os.name")
	private def => BooleanisWindows = => java.lang.Stringos.()java.lang.StringtoLowerCase.(java.lang.String)IntindexOf(java.lang.String("windows")"windows") (Int)Boolean>= Int(0)0
	private def => BooleanformatExplicitlyDisabled = java.lang.object java.lang.BooleanBoolean.(java.lang.String)BooleangetBoolean(java.lang.String("sbt.log.noformat")"sbt.log.noformat")
	private val BooleanformatEnabled = => Boolean!(=> BooleanformatExplicitlyDisabled (Boolean)Boolean|| => BooleanisWindows)
}

/** A logger that logs to the console.  On non-windows systems, the level labels are
* colored. 
*
* This logger is not thread-safe.*/
class class ConsoleLogger extends sbt.BasicLogger with ScalaObjectConsoleLogger extends sbt.BasicLoggerBasicLogger
{
	import ConsoleLogger.formatEnabled
	def (sbt.Level.Value)java.lang.StringmessageColor(sbt.Level.Valuelevel: Level.sbt.Level.ValueValue) = Console.java.lang.String("\033[0m")RESET
	def (sbt.Level.Value)java.lang.StringlabelColor(sbt.Level.Valuelevel: Level.sbt.Level.ValueValue) =
		sbt.Level.Valuelevel java.lang.Stringmatch
		{
			java.lang.String("\033[31m")case object sbt.LevelLevel.=> sbt.Level.ValueError => Console.java.lang.String("\033[31m")RED
			java.lang.String("\033[33m")case object sbt.LevelLevel.=> sbt.Level.ValueWarn => Console.java.lang.String("\033[33m")YELLOW
			java.lang.String("\033[0m")case _ => Console.java.lang.String("\033[0m")RESET
		}
	def => java.lang.StringsuccessLabelColor = Console.java.lang.String("\033[32m")GREEN
	def => java.lang.StringsuccessMessageColor = Console.java.lang.String("\033[0m")RESET
	override def (=> String)Unitsuccess(=> Stringmessage: => String)
	{
		Unitif((sbt.Level.Value)BooleanatLevel(object sbt.LevelLevel.=> sbt.Level.ValueInfo))
			(String,String,String,String)Unitlog(=> java.lang.StringsuccessLabelColor, object sbt.LevelLevel.=> java.lang.StringSuccessLabel, => java.lang.StringsuccessMessageColor, => Stringmessage)
	}
	def (=> Throwable)Unittrace(=> Throwablet: => Throwable): UnitUnit =
		object java.lang.SystemSystem.java.io.PrintStreamout.(Unit)Unitsynchronized
		{
			Unitif(=> BooleantraceEnabled)
				=> Throwablet.()UnitprintStackTrace
		}
	def (sbt.Level.Value,=> String)Unitlog(sbt.Level.Valuelevel: Level.sbt.Level.ValueValue, => Stringmessage: => String)
	{
		Unitif((sbt.Level.Value)BooleanatLevel(sbt.Level.Valuelevel))
			(String,String,String,String)Unitlog((sbt.Level.Value)java.lang.StringlabelColor(sbt.Level.Valuelevel), sbt.Level.Valuelevel.()java.lang.StringtoString, (sbt.Level.Value)java.lang.StringmessageColor(sbt.Level.Valuelevel), => Stringmessage)
	}
	private def (String)UnitsetColor(Stringcolor: StringString)
	{
		Unitif(=> BooleanformatEnabled)
			object java.lang.SystemSystem.java.io.PrintStreamout.(Unit)Unitsynchronized { object java.lang.SystemSystem.java.io.PrintStreamout.(java.lang.String)Unitprint(Stringcolor) }
	}
	private def (String,String,String,String)Unitlog(StringlabelColor: StringString, Stringlabel: StringString, StringmessageColor: StringString, Stringmessage: StringString): UnitUnit =
		object java.lang.SystemSystem.java.io.PrintStreamout.(Unit)Unitsynchronized
		{
			for(((java.lang.String) => Unit)Unitline <- Stringmessage.(java.lang.String)Array[java.lang.String]split(java.lang.String("\n")"""\n"""))
			{
				(String)UnitsetColor(Console.java.lang.String("\033[0m")RESET)
				object java.lang.SystemSystem.java.io.PrintStreamout.(Char)Unitprint(Char('[')'[')
				(String)UnitsetColor(StringlabelColor)
				object java.lang.SystemSystem.java.io.PrintStreamout.(java.lang.String)Unitprint(Stringlabel)
				(String)UnitsetColor(Console.java.lang.String("\033[0m")RESET)
				object java.lang.SystemSystem.java.io.PrintStreamout.(java.lang.String)Unitprint(java.lang.String("] ")"] ")
				(String)UnitsetColor(StringmessageColor)
				object java.lang.SystemSystem.java.io.PrintStreamout.(java.lang.String)Unitprint(java.lang.Stringline)
				(String)UnitsetColor(Console.java.lang.String("\033[0m")RESET)
				object java.lang.SystemSystem.java.io.PrintStreamout.()Unitprintln()
			}
		}
	
	def (Seq[sbt.LogEvent])UnitlogAll(Seq[sbt.LogEvent]events: Seq[sbt.LogEvent]Seq[LogEvent]) = object java.lang.SystemSystem.java.io.PrintStreamout.(Unit)Unitsynchronized { Seq[sbt.LogEvent]events.((sbt.LogEvent) => Unit)Unitforeach((sbt.LogEvent)Unitlog) }
	def (sbt.ControlEvent.Value,=> String)Unitcontrol(sbt.ControlEvent.Valueevent: ControlEvent.sbt.ControlEvent.ValueValue, => Stringmessage: => String)
		{ (String,String,String,String)Unitlog((sbt.Level.Value)java.lang.StringlabelColor(object sbt.LevelLevel.=> sbt.Level.ValueInfo), object sbt.LevelLevel.=> sbt.Level.ValueInfo.()java.lang.StringtoString, Console.java.lang.String("\033[34m")BLUE, => Stringmessage) }
}

/** An enumeration defining the levels available for logging.  A level includes all of the levels
* with id larger than its own id.  For example, Warn (id=3) includes Error (id=4).*/
object object sbt.LevelLevel extends EnumerationEnumeration with NotNullNotNull
{
	val sbt.Level.ValueDebug = (Int,String)sbt.Level.ValueValue(Int(1)1, java.lang.String("debug")"debug")
	val sbt.Level.ValueInfo = (Int,String)sbt.Level.ValueValue(Int(2)2, java.lang.String("info")"info")
	val sbt.Level.ValueWarn = (Int,String)sbt.Level.ValueValue(Int(3)3, java.lang.String("warn")"warn")
	val sbt.Level.ValueError = (Int,String)sbt.Level.ValueValue(Int(4)4, java.lang.String("error")"error")
	/** Defines the label to use for success messages.  A success message is logged at the info level but
	* uses this label.  Because the label for levels is defined in this module, the success
	* label is also defined here. */
	val java.lang.StringSuccessLabel = java.lang.String("success")"success"
	
	/** Returns the level with the given name wrapped in Some, or None if no level exists for that name. */
	def (String)Option[sbt.Level.Value]apply(Strings: StringString) = => Iterator[sbt.Level.Value]elements.((sbt.Level.Value) => Boolean)Option[sbt.Level.Value]find(Strings (AnyRef)Boolean== sbt.Level.Value_.()java.lang.StringtoString)
	/** Same as apply, defined for use in pattern matching. */
	private[sbt] def (String)Option[sbt.Level.Value]unapply(Strings: StringString) = (String)Option[sbt.Level.Value]apply(Strings)
}