/* sbt -- Simple Build Tool
 * Copyright 2009  Mark Harrah
 */
 package sbt.impl

import scala.collection.{immutable, jcl, mutable}
import scala.collection.Map
import jcl.IdentityHashMap

private[sbt] object object sbt.impl.RunTaskRunTask
{
	final type sbt.Project#TaskTask = Project#sbt.Project#TaskTask
	val java.lang.StringUnnamedName = java.lang.String("<anonymous>")"<anonymous>"
	def (sbt.impl.RunTask.Task,String)List[sbt.WorkFailure[sbt.impl.RunTask.Task]]apply(sbt.impl.RunTask.Taskroot: sbt.impl.RunTask.TaskTask, StringrootName: StringString): List[sbt.WorkFailure[sbt.impl.RunTask.Task]]List[WorkFailure[Task]]  = (sbt.impl.RunTask.Task,String,Boolean)List[sbt.WorkFailure[sbt.impl.RunTask.Task]]apply(sbt.impl.RunTask.Taskroot, StringrootName, Boolean(true)true)
	def (sbt.impl.RunTask.Task,String,Boolean)List[sbt.WorkFailure[sbt.impl.RunTask.Task]]apply(sbt.impl.RunTask.Taskroot: sbt.impl.RunTask.TaskTask, StringrootName: StringString, BooleanparallelExecution: BooleanBoolean): List[sbt.WorkFailure[sbt.impl.RunTask.Task]]List[WorkFailure[Task]] =
		(sbt.impl.RunTask.Task,String,Int)List[sbt.WorkFailure[sbt.impl.RunTask.Task]]apply(sbt.impl.RunTask.Taskroot, StringrootName, Intif(BooleanparallelExecution) object java.lang.RuntimeRuntime.()java.lang.RuntimegetRuntime.()IntavailableProcessors else Int(1)1)
	def (sbt.impl.RunTask.Task,String,Int)List[sbt.WorkFailure[sbt.impl.RunTask.Task]]apply(sbt.impl.RunTask.Taskroot: sbt.impl.RunTask.TaskTask, StringrootName: StringString, IntmaximumTasks: IntInt): List[sbt.WorkFailure[sbt.impl.RunTask.Task]]List[WorkFailure[Task]]  = (sbt.impl.RunTasknew sbt.impl.RunTaskRunTask(sbt.impl.RunTask.Taskroot, StringrootName, IntmaximumTasks)).()List[sbt.WorkFailure[sbt.impl.RunTask.Task]]run()
}
import RunTask._
private final class class RunTask extends java.lang.Object with NotNull with ScalaObjectRunTask(sbt.impl.RunTask.Taskroot: sbt.impl.RunTask.TaskTask, StringrootName: StringString, IntmaximumTasks: IntInt) extends NotNullNotNull
{
	(Boolean)Unitrequire(IntmaximumTasks (Int)Boolean>= Int(1)1)
	def => Booleanparallel = IntmaximumTasks (Int)Boolean> Int(1)1
	def => BooleanmultiProject = => scala.collection.immutable.Set[sbt.Project#ManagerType]allProjects.=> Intsize (Int)Boolean>= Int(2)2
	def ()List[sbt.WorkFailure[sbt.impl.RunTask.Task]]run(): List[sbt.WorkFailure[sbt.impl.RunTask.Task]]List[WorkFailure[Task]]  =
	{
		try
		{
			()List[sbt.WorkFailure[sbt.impl.RunTask.Task]]runTasksExceptRoot() List[sbt.WorkFailure[sbt.impl.RunTask.Task]]match
			{
				List[sbt.WorkFailure[sbt.impl.RunTask.Task]]case object NilNil =>
					val Option[String]result = (sbt.impl.RunTask.Task,String)Option[String]runTask(sbt.impl.RunTask.Taskroot, StringrootName)
					Option[String]result.((String) => sbt.WorkFailure[sbt.impl.RunTask.Task])Option[sbt.WorkFailure[sbt.impl.RunTask.Task]]map( StringerrorMessage => (sbt.impl.RunTask.Task,String)sbt.WorkFailure[sbt.impl.RunTask.Task]WorkFailure(sbt.impl.RunTask.Taskroot, java.lang.String("Error running ")"Error running " (Any)java.lang.String+ StringrootName (Any)java.lang.String+ java.lang.String(": ")": " (Any)java.lang.String+ StringerrorMessage) ).=> List[sbt.WorkFailure[sbt.impl.RunTask.Task]]toList
				List[sbt.WorkFailure[sbt.impl.RunTask.Task]]case List[sbt.WorkFailure[sbt.impl.RunTask.Task]]failures => List[sbt.WorkFailure[sbt.impl.RunTask.Task]]failures
			}
		}
		finally
		{
			for(((sbt.Project#ManagerType) => Unit)Unitproject <- => scala.collection.immutable.Set[sbt.Project#ManagerType]allProjects; ((String) => Unit)UnitsaveError <- sbt.Project#ManagerTypeproject.()Option[String]saveEnvironment)
				sbt.Project#ManagerTypeproject.=> sbt.Loggerlog.(=> String)Unitwarn(java.lang.String("Could not save properties for project ")"Could not save properties for project " (Any)java.lang.String+ sbt.Project#ManagerTypeproject.=> Stringname (Any)java.lang.String+ java.lang.String(": ")": " (Any)java.lang.String+ StringsaveError)
		}
	}
	// This runs all tasks except the root.task.
	// It uses a buffered logger in record mode to ensure that all output for a given task is consecutive
	// it ignores the root task so that the root task may be run with buffering disabled so that the output
	// occurs without delay.
	private def ()List[sbt.WorkFailure[sbt.impl.RunTask.Task]]runTasksExceptRoot() =
	{
		((sbt.BufferedLogger) => Unit)UnitwithBuffered(sbt.BufferedLogger_.()UnitstartRecording())
		try { object sbt.ParallelRunnerParallelRunner.(sbt.impl.RunTask.Task,(sbt.impl.RunTask.Task) => String,(sbt.impl.RunTask.Task) => Option[String],Int,(sbt.impl.RunTask.Task) => sbt.Logger)List[sbt.WorkFailure[sbt.impl.RunTask.Task]]run(=> sbt.impl.RunTask.TaskexpandedRoot, (sbt.impl.RunTask.Task)StringexpandedTaskName, (sbt.impl.RunTask.Task)Option[String]runIfNotRoot, IntmaximumTasks, (sbt.impl.RunTask.Taskt: sbt.impl.RunTask.TaskTask) => sbt.impl.RunTask.Taskt.=> sbt.Project#ManagerTypemanager.=> sbt.Loggerlog) }
		finally { ((sbt.BufferedLogger) => Unit)UnitwithBuffered(sbt.BufferedLogger_.()Unitstop()) }
	}
	private def ((sbt.BufferedLogger) => Unit)UnitwithBuffered((sbt.BufferedLogger) => Unitf: BufferedLogger => Unit)
	{
		for(((sbt.BufferedLogger) => Unit)Unitbuffered <- => List[sbt.BufferedLogger]bufferedLoggers)
			object sbt.ControlControl.(=> Unit)Unittrap((sbt.BufferedLogger)Unitf(sbt.BufferedLoggerbuffered))
	}
	/** Will be called in its own actor. Runs the given task if it is not the root task.*/
	private def (sbt.impl.RunTask.Task)Option[String]runIfNotRoot(sbt.impl.RunTask.Taskaction: sbt.impl.RunTask.TaskTask): Option[String]Option[String] =
	{
		Option[String]if((sbt.impl.RunTask.Task)BooleanisRoot(sbt.impl.RunTask.Taskaction))
			object NoneNone
		else
			(sbt.impl.RunTask.Task,String)Option[String]runTask(sbt.impl.RunTask.Taskaction, (sbt.impl.RunTask.Task)StringexpandedTaskName(sbt.impl.RunTask.Taskaction))
	}
	private def (sbt.impl.RunTask.Task)BooleanisRoot(sbt.impl.RunTask.Taskt: sbt.impl.RunTask.TaskTask) = sbt.impl.RunTask.Taskt (AnyRef)Boolean== => sbt.impl.RunTask.TaskexpandedRoot
	/** Will be called in its own actor except for the root task. */
	private def (sbt.impl.RunTask.Task,String)Option[String]runTask(sbt.impl.RunTask.Taskaction: sbt.impl.RunTask.TaskTask, StringactionName: StringString): Option[String]Option[String] =
	{
		val java.lang.Stringlabel = java.lang.Stringif(=> BooleanmultiProject) (sbt.impl.RunTask.Taskaction.=> sbt.Project#ManagerTypemanager.=> Stringname (Any)java.lang.String+ java.lang.String(" / ")" / " (Any)java.lang.String+ StringactionName) else StringactionName
		def (sbt.ControlEvent.Value,String,String)Unitbanner(sbt.ControlEvent.Valueevent: ControlEvent.sbt.ControlEvent.ValueValue, StringfirstSeparator: StringString, StringsecondSeparator: StringString) =
			object sbt.ControlControl.(=> Unit)Unittrap(sbt.impl.RunTask.Taskaction.=> sbt.Project#ManagerTypemanager.=> sbt.Loggerlog.(sbt.ControlEvent.Value,=> String)Unitcontrol(sbt.ControlEvent.Valueevent, StringfirstSeparator (Any)java.lang.String+ java.lang.String(" ")" " (Any)java.lang.String+ java.lang.Stringlabel (Any)java.lang.String+ java.lang.String(" ")" " (Any)java.lang.String+ StringsecondSeparator))
		Unitif(=> Booleanparallel)
		{
			try { (sbt.ControlEvent.Value,String,String)Unitbanner(object sbt.ControlEventControlEvent.=> sbt.ControlEvent.ValueStart, java.lang.String("\012  ")"\n  ", java.lang.String("...")"...") }
			finally { (sbt.impl.RunTask.Task)Unitflush(sbt.impl.RunTask.Taskaction) }
		}
		(sbt.ControlEvent.Value,String,String)Unitbanner(object sbt.ControlEventControlEvent.=> sbt.ControlEvent.ValueHeader, java.lang.String("\012==")"\n==", java.lang.String("==")"==")
		try { sbt.impl.RunTask.Taskaction.=> Option[String]invoke }
		catch { Some[java.lang.String]case Exceptione: ExceptionException => sbt.impl.RunTask.Taskaction.=> sbt.Project#ManagerTypemanager.=> sbt.Loggerlog.(=> Throwable)Unittrace(Exceptione); (java.lang.String)Some[java.lang.String]Some(Exceptione.()java.lang.StringtoString) }
		finally
		{
			(sbt.ControlEvent.Value,String,String)Unitbanner(object sbt.ControlEventControlEvent.=> sbt.ControlEvent.ValueFinish, java.lang.String("==")"==", java.lang.String("==")"==")
			Unitif(=> Booleanparallel)
				(sbt.impl.RunTask.Task)Unitflush(sbt.impl.RunTask.Taskaction)
		}
	}
	private def (=> Unit)(=> Unit)UnittrapFinally(=> UnittoTrap: => Unit)(=> UnitrunFinally: => Unit)
	{
		try { => UnittoTrap }
		catch { Unitcase Exceptione: ExceptionException => Unit() }
		finally { try { => UnitrunFinally } catch { Unitcase Exceptione: ExceptionException => Unit() } }
	}
	private def (sbt.impl.RunTask.Task)Unitflush(sbt.impl.RunTask.Taskaction: sbt.impl.RunTask.TaskTask)
	{
		for(((sbt.BufferedLogger) => Unit)Unitbuffered <- (sbt.Project)Option[sbt.BufferedLogger]bufferedLogger(sbt.impl.RunTask.Taskaction.=> sbt.Project#ManagerTypemanager))
			object sbt.ControlControl.(=> Unit)Unittrap((sbt.BufferedLogger)Unitflush(sbt.BufferedLoggerbuffered))
	}
	private def (sbt.BufferedLogger)Unitflush(sbt.BufferedLoggerbuffered: sbt.BufferedLoggerBufferedLogger)
	{
		sbt.BufferedLoggerbuffered.()Unitplay()
		sbt.BufferedLoggerbuffered.()Unitclear()
	}

	/* Most of the following is for implicitly adding dependencies (see the expand method)*/
	private val scala.collection.jcl.IdentityHashMap[sbt.Project,Iterable[sbt.Project]]projectDependencyCache = ()scala.collection.jcl.IdentityHashMap[sbt.Project,Iterable[sbt.Project]]new scala.collection.jcl.IdentityHashMap[sbt.Project,Iterable[sbt.Project]]IdentityHashMap[Project, Iterable[Project]]
	private def (sbt.Project)Iterable[sbt.Project]dependencies(sbt.Projectproject: sbt.ProjectProject) = => scala.collection.jcl.IdentityHashMap[sbt.Project,Iterable[sbt.Project]]projectDependencyCache.(sbt.Project,=> Iterable[sbt.Project])Iterable[sbt.Project]getOrElseUpdate(sbt.Projectproject, sbt.Projectproject.=> List[sbt.Project]topologicalSort.(Int)List[sbt.Project]dropRight(Int(1)1))

	private val scala.collection.jcl.IdentityHashMap[sbt.impl.RunTask.Task,sbt.impl.RunTask.Task]expandedCache = ()scala.collection.jcl.IdentityHashMap[sbt.impl.RunTask.Task,sbt.impl.RunTask.Task]new scala.collection.jcl.IdentityHashMap[sbt.impl.RunTask.Task,sbt.impl.RunTask.Task]IdentityHashMap[Task, Task]
	private def (sbt.impl.RunTask.Task)sbt.impl.RunTask.Taskexpanded(sbt.impl.RunTask.Tasktask: sbt.impl.RunTask.TaskTask): sbt.impl.RunTask.TaskTask = => scala.collection.jcl.IdentityHashMap[sbt.impl.RunTask.Task,sbt.impl.RunTask.Task]expandedCache.(sbt.impl.RunTask.Task,=> sbt.impl.RunTask.Task)sbt.impl.RunTask.TaskgetOrElseUpdate(sbt.impl.RunTask.Tasktask, (sbt.impl.RunTask.Task)sbt.impl.RunTask.TaskexpandImpl(sbt.impl.RunTask.Tasktask))

	private val scala.collection.jcl.IdentityHashMap[sbt.impl.RunTask.Task,String]expandedTaskNameCache = ()scala.collection.jcl.IdentityHashMap[sbt.impl.RunTask.Task,String]new scala.collection.jcl.IdentityHashMap[sbt.impl.RunTask.Task,String]IdentityHashMap[Task, String]
	private def (sbt.impl.RunTask.Task)StringexpandedTaskName(sbt.impl.RunTask.Tasktask: sbt.impl.RunTask.TaskTask) =
		Stringif(sbt.impl.RunTask.Tasktask (AnyRef)Boolean== => sbt.impl.RunTask.TaskexpandedRoot)
			StringrootName
		else
			=> scala.collection.jcl.IdentityHashMap[sbt.impl.RunTask.Task,String]expandedTaskNameCache.(sbt.impl.RunTask.Task,=> String)StringgetOrElse(sbt.impl.RunTask.Tasktask, => java.lang.StringUnnamedName)

	private val scala.collection.jcl.IdentityHashMap[sbt.Project,scala.collection.Map[String,sbt.impl.RunTask.Task]]nameToTaskCache = ()scala.collection.jcl.IdentityHashMap[sbt.Project,scala.collection.Map[String,sbt.impl.RunTask.Task]]new scala.collection.jcl.IdentityHashMap[sbt.Project,scala.collection.Map[String,sbt.impl.RunTask.Task]]IdentityHashMap[Project, Map[String, Task]]
	private def (sbt.Project)scala.collection.Map[String,sbt.impl.RunTask.Task]nameToTaskMap(sbt.Projectproject: sbt.ProjectProject): scala.collection.Map[String,sbt.impl.RunTask.Task]Map[String, Task] = => scala.collection.jcl.IdentityHashMap[sbt.Project,scala.collection.Map[String,sbt.impl.RunTask.Task]]nameToTaskCache.(sbt.Project,=> scala.collection.Map[String,sbt.impl.RunTask.Task])scala.collection.Map[String,sbt.impl.RunTask.Task]getOrElseUpdate(sbt.Projectproject, sbt.Projectproject.=> scala.collection.Map[String,project.Task]tasks)
	private def (sbt.Project,String)Option[sbt.impl.RunTask.Task]taskForName(sbt.Projectproject: sbt.ProjectProject, Stringname: StringString): Option[sbt.impl.RunTask.Task]Option[Task] = (sbt.Project)scala.collection.Map[String,sbt.impl.RunTask.Task]nameToTaskMap(sbt.Projectproject).(String)Option[sbt.impl.RunTask.Task]get(Stringname)
	
	private val scala.collection.jcl.IdentityHashMap[sbt.Project,scala.collection.Map[sbt.impl.RunTask.Task,String]]taskNameCache = ()scala.collection.jcl.IdentityHashMap[sbt.Project,scala.collection.Map[sbt.impl.RunTask.Task,String]]new scala.collection.jcl.IdentityHashMap[sbt.Project,scala.collection.Map[sbt.impl.RunTask.Task,String]]IdentityHashMap[Project, Map[Task, String]]
	private def (sbt.impl.RunTask.Task)Option[String]taskName(sbt.impl.RunTask.Tasktask: sbt.impl.RunTask.TaskTask) =
	{
		val sbt.Project#ManagerTypeproject = sbt.impl.RunTask.Tasktask.=> sbt.Project#ManagerTypemanager
		=> scala.collection.jcl.IdentityHashMap[sbt.Project,scala.collection.Map[sbt.impl.RunTask.Task,String]]taskNameCache.(sbt.Project,=> scala.collection.Map[sbt.impl.RunTask.Task,String])scala.collection.Map[sbt.impl.RunTask.Task,String]getOrElseUpdate(sbt.Project#ManagerTypeproject, (sbt.Project)scala.collection.mutable.Map[sbt.impl.RunTask.Task,String]taskNameMap(sbt.Project#ManagerTypeproject)).(sbt.impl.RunTask.Task)Option[String]get(sbt.impl.RunTask.Tasktask)
	}
	
	private val sbt.impl.RunTask.TaskexpandedRoot = (sbt.impl.RunTask.Task)sbt.impl.RunTask.Taskexpand(sbt.impl.RunTask.Taskroot)
	private val List[sbt.Project#ManagedTask]allTasks = => sbt.impl.RunTask.TaskexpandedRoot.=> List[sbt.Project#ManagedTask]topologicalSort
	private val scala.collection.immutable.Set[sbt.Project#ManagerType]allProjects = (sbt.Project#ManagerType*)scala.collection.immutable.Set[sbt.Project#ManagerType]Set(=> List[sbt.Project#ManagedTask]allTasks.((sbt.Project#ManagedTask) => sbt.Project#ManagerType)List[sbt.Project#ManagerType]map(sbt.Project#ManagedTask_.=> sbt.Project#ManagerTypemanager).=> Seq[sbt.Project#ManagerType]toSeq : _*)
	private val List[sbt.BufferedLogger]bufferedLoggers = List[sbt.BufferedLogger]if(=> Booleanparallel) => scala.collection.immutable.Set[sbt.Project#ManagerType]allProjects.=> List[sbt.Project#ManagerType]toList.((sbt.Project#ManagerType) => Iterable[sbt.BufferedLogger])List[sbt.BufferedLogger]flatMap((Option[sbt.BufferedLogger])Iterable[sbt.BufferedLogger]bufferedLogger) else object NilNil
	
	/** Adds implicit dependencies, which are tasks with the same name in the project dependencies
	* of the enclosing project of the task.*/
	private def (sbt.impl.RunTask.Task)sbt.impl.RunTask.Taskexpand(sbt.impl.RunTask.Taskroot: sbt.impl.RunTask.TaskTask): sbt.impl.RunTask.TaskTask = (sbt.impl.RunTask.Task)sbt.impl.RunTask.Taskexpanded(sbt.impl.RunTask.Taskroot)
	private def (sbt.impl.RunTask.Task)sbt.impl.RunTask.TaskexpandImpl(sbt.impl.RunTask.Tasktask: sbt.impl.RunTask.TaskTask): sbt.impl.RunTask.TaskTask =
	{
		val Option[String]nameOption = (sbt.impl.RunTask.Task)Option[String]taskName(sbt.impl.RunTask.Tasktask)
		val List[sbt.Project#ManagedTask]explicitDependencies = sbt.impl.RunTask.Tasktask.=> List[sbt.Project#ManagedTask]dependencies
		val Iterable[sbt.impl.RunTask.Task]implicitDependencies = Option[String]nameOption.((String) => Iterable[sbt.impl.RunTask.Task])Option[Iterable[sbt.impl.RunTask.Task]]map(Stringname => (sbt.Project)Iterable[sbt.Project]dependencies(sbt.impl.RunTask.Tasktask.=> sbt.Project#ManagerTypemanager).((sbt.Project) => Iterable[sbt.impl.RunTask.Task])Iterable[sbt.impl.RunTask.Task]flatMap((Option[sbt.impl.RunTask.Task])Iterable[sbt.impl.RunTask.Task]noninteractiveTask(Stringname)) ).(=> Iterable[sbt.impl.RunTask.Task])Iterable[sbt.impl.RunTask.Task]getOrElse(object NilNil)
		val scala.collection.mutable.Set[sbt.Project#ManagedTask]allDependencies = mutable.(sbt.Project#ManagedTask*)scala.collection.mutable.Set[sbt.Project#ManagedTask]HashSet( (List[sbt.Project#ManagedTask]explicitDependencies (Iterable[sbt.Project#ManagedTask])List[sbt.Project#ManagedTask]++ Iterable[sbt.impl.RunTask.Task]implicitDependencies).=> Seq[sbt.Project#ManagedTask]toSeq  : _* )
		val sbt.Project#TaskexpandedTask = sbt.impl.RunTask.Tasktask.((List[_76.ManagedTask])_76.Task) forSome { val _76: sbt.Project }setDependencies(scala.collection.mutable.Set[sbt.Project#ManagedTask]allDependencies.=> List[sbt.Project#ManagedTask]toList.((sbt.Project#ManagedTask) => sbt.impl.RunTask.Task)List[sbt.impl.RunTask.Task]map((sbt.impl.RunTask.Task)sbt.impl.RunTask.Taskexpanded))
		Option[String]nameOption.((String) => Unit)Unitforeach(Stringname => => scala.collection.jcl.IdentityHashMap[sbt.impl.RunTask.Task,String]expandedTaskNameCache(sbt.Project#TaskexpandedTask) = Stringname)
		sbt.Project#TaskexpandedTask
	}
	private def (String)(sbt.Project)Option[sbt.impl.RunTask.Task]noninteractiveTask(Stringname: StringString)(sbt.Projectproject: sbt.ProjectProject): Option[sbt.impl.RunTask.Task]Option[Task] =
		(sbt.Project,String)Option[sbt.impl.RunTask.Task]taskForName(sbt.Projectproject, Stringname) ((sbt.impl.RunTask.Task) => Option[sbt.impl.RunTask.Task])Option[sbt.impl.RunTask.Task]flatMap { sbt.impl.RunTask.Tasktask =>
			Option[sbt.impl.RunTask.Task]if(sbt.impl.RunTask.Tasktask.=> Booleaninteractive)
			{
				sbt.Projectproject.=> sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Not including task ")"Not including task " (Any)java.lang.String+ Stringname (Any)java.lang.String+ java.lang.String(" in project ")" in project " (Any)java.lang.String+ sbt.Projectproject.=> Stringname (Any)java.lang.String+ java.lang.String(": interactive tasks can only be run directly.")": interactive tasks can only be run directly.")
				object NoneNone
			}
			else
				(sbt.impl.RunTask.Task)Some[sbt.impl.RunTask.Task]Some(sbt.impl.RunTask.Tasktask)
		}
	private def (sbt.Project)scala.collection.mutable.Map[sbt.impl.RunTask.Task,String]taskNameMap(sbt.Projectproject: sbt.ProjectProject) = mutable.((sbt.impl.RunTask.Task, String)*)scala.collection.mutable.Map[sbt.impl.RunTask.Task,String]Map((sbt.Project)scala.collection.Map[String,sbt.impl.RunTask.Task]nameToTaskMap(sbt.Projectproject).(((String, sbt.impl.RunTask.Task)) => (sbt.impl.RunTask.Task, String))Iterable[(sbt.impl.RunTask.Task, String)]map((String, sbt.impl.RunTask.Task)_.=> (sbt.impl.RunTask.Task, String)swap).=> Seq[(sbt.impl.RunTask.Task, String)]toSeq : _*)
	private def (sbt.Project)Option[sbt.BufferedLogger]bufferedLogger(sbt.Projectproject: sbt.ProjectProject): Option[sbt.BufferedLogger]Option[BufferedLogger] =
		sbt.Projectproject.=> sbt.Loggerlog Option[sbt.BufferedLogger]match
		{
			Some[sbt.BufferedLogger]case sbt.BufferedLoggerbuffered: sbt.BufferedLoggerBufferedLogger => (sbt.BufferedLogger)Some[sbt.BufferedLogger]Some(sbt.BufferedLoggerbuffered)
			None.typecase _ => object NoneNone
		}
}