object EvaluateTask
- Source
- EvaluateTask.scala
- Alphabetic
- By Inheritance
- EvaluateTask
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
- type AnyCyclic = CyclicException[_]
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- val SystemProcessors: Int
-
def
apply[T](structure: BuildStructure, taskKey: Def.ScopedKey[Task[T]], state: State, ref: ProjectRef, config: EvaluateTaskConfig): Option[(State, Result[T])]
Evaluates
taskKey
and returns the new State and the result of the task wrapped in Some.Evaluates
taskKey
and returns the new State and the result of the task wrapped in Some. If the task is not defined, None is returned. The provided task key is resolved against the current projectref
.config
configures concurrency and canceling of task execution. -
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.Evaluates
taskKey
and returns the new State and the result of the task wrapped in Some. If the task is not defined, None is returned. The provided task key is resolved against the current projectref
. Task execution is configured according to settings defined in the loaded project. - def applyResults[T](results: RMap[Task, Result], state: State, root: Task[T]): (State, Result[T])
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
- def cancelStrategy(extracted: Extracted, structure: BuildStructure, state: State): TaskCancellationStrategy
- def cancelable(extracted: Extracted, structure: BuildStructure): Boolean
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
- def convertCyclic(c: AnyCyclic): String
- def convertCyclicInc: (Incomplete) ⇒ Incomplete
- val currentlyRunningEngine: AtomicReference[(SafeState, RunningTaskEngine)]
- def defaultRestrictions(extracted: Extracted, structure: BuildStructure): Seq[Rule]
- def defaultRestrictions(maxWorkers: Int): List[Rule]
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def evalPluginDef(pluginDef: BuildStructure, state: State): PluginData
- def extractedTaskConfig(extracted: Extracted, structure: BuildStructure, state: State): EvaluateTaskConfig
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- 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
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def injectSettings: Seq[Def.Setting[_]]
- val injectStreams: (Def.ScopedKey[_]) ⇒ Seq[Def.Setting[_]]
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- val lastEvaluatedState: AtomicReference[SafeState]
- 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
- Definition Classes
- AnyRef
- def nodeView[HL <: HList](state: State, streams: Streams, roots: Seq[Def.ScopedKey[_]], dummies: DummyTaskMap = DummyTaskMap(Nil)): NodeView[Task]
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def onResult[T, S](result: Result[T])(f: (T) ⇒ S): S
- def processResult2[T](result: Result[T], 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])
The main method for the task engine.
The main method for the task engine. See also Aggregation.runTasks.
- 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
- Definition Classes
- AnyRef
- def taskTimingProgress: Option[ExecuteProgress[Task]]
- def taskToKey: (Incomplete) ⇒ Incomplete
- def taskTraceEvent: Option[ExecuteProgress[Task]]
-
def
toString(): String
- Definition Classes
- AnyRef → Any
- def transformInc[T](result: Result[T]): Result[T]
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
- def withStreams[T](structure: BuildStructure, state: State)(f: (Streams) ⇒ T): T
Deprecated Value Members
-
def
evalPluginDef(log: Logger)(pluginDef: BuildStructure, state: State): PluginData
- Annotations
- @deprecated
- Deprecated
(Since version 1.1.1) Use variant which doesn't take a logger
-
def
onResult[T, S](result: Result[T], log: Logger)(f: (T) ⇒ S): S
- Annotations
- @deprecated
- Deprecated
(Since version 1.1.1) Use variant that doesn't take log
-
def
processResult[T](result: Result[T], log: Logger, show: Boolean = false): T
- Annotations
- @deprecated
- Deprecated
(Since version 1.1.1) Use processResult2 which doesn't take the unused log param