EvaluateTask

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

val SystemProcessors: Int

def apply[T](structure: BuildStructure, taskKey: Def.ScopedKey[Task[T]], state: State, ref: ProjectRef, config: EvaluateTaskConfig): Option[(State, Result[T])]

def apply[T](structure: BuildStructure, taskKey: Def.ScopedKey[Task[T]], state: State, ref: ProjectRef): Option[(State, Result[T])]

Evaluates taskKey and returns the new State and the result of the task wrapped in Some.

def applyResults[T](results: RMap[Task, Result], state: State, root: Task[T]): (State, Result[T])

final def asInstanceOf[T0]: T0

def cancelStrategy(extracted: Extracted, structure: BuildStructure, state: State): TaskCancellationStrategy

def cancelable(extracted: Extracted, structure: BuildStructure): Boolean

def clone(): AnyRef

def convertCyclic(c: AnyCyclic): String

def convertCyclicInc: (Incomplete) ⇒ Incomplete

def defaultRestrictions(extracted: Extracted, structure: BuildStructure): Seq[Rule]

def defaultRestrictions(maxWorkers: Int): List[Rule]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def evalPluginDef(log: Logger)(pluginDef: BuildStructure, state: State): PluginData

def extractedTaskConfig(extracted: Extracted, structure: BuildStructure, state: State): EvaluateTaskConfig

def finalize(): Unit

final def getClass(): Class[_]

def getSetting[T](key: SettingKey[T], default: T, extracted: Extracted, structure: BuildStructure): T

def getStreams(key: Def.ScopedKey[_], streams: Streams): TaskStreams

def getTask[T](structure: BuildStructure, taskKey: Def.ScopedKey[Task[T]], state: State, streams: Streams, ref: ProjectRef): Option[(Task[T], NodeView[Task])]

def hashCode(): Int

def injectSettings: Seq[Def.Setting[_]]

val injectStreams: (Def.ScopedKey[_]) ⇒ Seq[Def.Setting[_]]

final def isInstanceOf[T0]: Boolean

def liftAnonymous: (Incomplete) ⇒ Incomplete

def logIncResult(result: Result[_], state: State, streams: Streams): Unit

def logIncomplete(result: Incomplete, state: State, streams: Streams): Unit

def maxWorkers(extracted: Extracted, structure: BuildStructure): Int

final def ne(arg0: AnyRef): Boolean

def nodeView[HL <: HList](state: State, streams: Streams, roots: Seq[Def.ScopedKey[_]], dummies: DummyTaskMap = DummyTaskMap(Nil)): NodeView[Task]

final def notify(): Unit

final def notifyAll(): Unit

def onResult[T, S](result: Result[T], log: Logger)(f: (T) ⇒ S): S

def processResult[T](result: Result[T], log: Logger, show: Boolean = false): T

def restrictions(extracted: Extracted, structure: BuildStructure): Seq[Rule]

def restrictions(state: State): Seq[Rule]

def runTask[T](root: Task[T], state: State, streams: Streams, triggers: Triggers[Task], config: EvaluateTaskConfig)(implicit taskToNode: NodeView[Task]): (State, Result[T])

def stateTransform(results: RMap[Task, Result]): (State) ⇒ State

def suppressedMessage(key: Def.ScopedKey[_])(implicit display: Show[Def.ScopedKey[_]]): String

final def synchronized[T0](arg0: ⇒ T0): T0

def taskToKey: (Incomplete) ⇒ Incomplete

def toString(): String

def transformInc[T](result: Result[T]): Result[T]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def withStreams[T](structure: BuildStructure, state: State)(f: (Streams) ⇒ T): T

def apply[T](structure: BuildStructure, taskKey: Def.ScopedKey[Task[T]], state: State, ref: ProjectRef, config: EvaluateConfig): Option[(State, Result[T])]

Evaluates taskKey and returns the new State and the result of the task wrapped in Some.

def defaultConfig(extracted: Extracted, structure: BuildStructure): EvaluateConfig

def defaultConfig(state: State): EvaluateConfig

def evaluateTask[T](structure: BuildStructure, taskKey: Def.ScopedKey[Task[T]], state: State, ref: ProjectRef, checkCycles: Boolean = false, maxWorkers: Int = SystemProcessors): Option[Result[T]]

def extractedConfig(extracted: Extracted, structure: BuildStructure, state: State): EvaluateConfig

def extractedConfig(extracted: Extracted, structure: BuildStructure): EvaluateConfig

def runTask[T](root: Task[T], state: State, streams: Streams, triggers: Triggers[Task], config: EvaluateConfig)(implicit taskToNode: NodeView[Task]): (State, Result[T])