luke
/
sbt
mirror of https://github.com/sbt/sbt.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Refactor ExecuteProgress type parameters

This commit is contained in:
Eugene Yokota 2018-09-27 11:48:30 -04:00
parent e2923541b1
commit 4be4017f06
1 changed files with 14 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
tasks/src/main/scala/sbt/ExecuteProgress.scala
View File

@ -17,7 +17,7 @@ import sbt.internal.util.RMap
* *
* This class is experimental and subject to binary and source incompatible changes at any time. * This class is experimental and subject to binary and source incompatible changes at any time.
*/ */
private[sbt] trait ExecuteProgress[A[_]] { private[sbt] trait ExecuteProgress[F[_]] {
type S type S
def initial: S def initial: S
@ -26,20 +26,20 @@ private[sbt] trait ExecuteProgress[A[_]] {
* The dependencies of `task` are `allDeps` and the subset of those dependencies that * The dependencies of `task` are `allDeps` and the subset of those dependencies that
* have not completed are `pendingDeps`. * have not completed are `pendingDeps`.
*/ */
def registered(state: S, task: A[_], allDeps: Iterable[A[_]], pendingDeps: Iterable[A[_]]): S def registered(state: S, task: F[_], allDeps: Iterable[F[_]], pendingDeps: Iterable[F[_]]): S
/** /**
* Notifies that all of the dependencies of `task` have completed and `task` is therefore * Notifies that all of the dependencies of `task` have completed and `task` is therefore
* ready to run. The task has not been scheduled on a thread yet. * ready to run. The task has not been scheduled on a thread yet.
*/ */
def ready(state: S, task: A[_]): S def ready(state: S, task: F[_]): S
/** /**
* Notifies that the work for `task` is starting after this call returns. * Notifies that the work for `task` is starting after this call returns.
* This is called from the thread the task executes on, unlike most other methods in this callback. * This is called from the thread the task executes on, unlike most other methods in this callback.
* It is called immediately before the task's work starts with minimal intervening executor overhead. * It is called immediately before the task's work starts with minimal intervening executor overhead.
*/ */
def workStarting(task: A[_]): Unit def workStarting(task: F[_]): Unit
/** /**
* Notifies that the work for `task` work has finished. The task may have computed the next task to * Notifies that the work for `task` work has finished. The task may have computed the next task to
@ -49,30 +49,30 @@ private[sbt] trait ExecuteProgress[A[_]] {
* This is called from the thread the task executes on, unlike most other methods in this callback. * This is called from the thread the task executes on, unlike most other methods in this callback.
* It is immediately called after the task's work is complete with minimal intervening executor overhead. * It is immediately called after the task's work is complete with minimal intervening executor overhead.
*/ */
def workFinished[T](task: A[T], result: Either[A[T], Result[T]]): Unit def workFinished[A](task: F[A], result: Either[F[A], Result[A]]): Unit
/** /**
* Notifies that `task` has completed. * Notifies that `task` has completed.
* The task's work is done with a final `result`. * The task's work is done with a final `result`.
* Any tasks called by `task` have completed. * Any tasks called by `task` have completed.
*/ */
def completed[T](state: S, task: A[T], result: Result[T]): S def completed[A](state: S, task: F[A], result: Result[A]): S
/** All tasks have completed with the final `results` provided. */ /** All tasks have completed with the final `results` provided. */
def allCompleted(state: S, results: RMap[A, Result]): S def allCompleted(state: S, results: RMap[F, Result]): S
} }
/** This module is experimental and subject to binary and source incompatible changes at any time. */ /** This module is experimental and subject to binary and source incompatible changes at any time. */
private[sbt] object ExecuteProgress { private[sbt] object ExecuteProgress {
def empty[A[_]]: ExecuteProgress[A] = new ExecuteProgress[A] { def empty[F[_]]: ExecuteProgress[F] = new ExecuteProgress[F] {
type S = Unit type S = Unit
def initial = () def initial = ()
def registered(state: Unit, task: A[_], allDeps: Iterable[A[_]], pendingDeps: Iterable[A[_]]) = def registered(state: Unit, task: F[_], allDeps: Iterable[F[_]], pendingDeps: Iterable[F[_]]) =
() ()
def ready(state: Unit, task: A[_]) = () def ready(state: Unit, task: F[_]) = ()
def workStarting(task: A[_]) = () def workStarting(task: F[_]) = ()
def workFinished[T](task: A[T], result: Either[A[T], Result[T]]) = () def workFinished[A](task: F[A], result: Either[F[A], Result[A]]) = ()
def completed[T](state: Unit, task: A[T], result: Result[T]) = () def completed[A](state: Unit, task: F[A], result: Result[A]) = ()
def allCompleted(state: Unit, results: RMap[A, Result]) = () def allCompleted(state: Unit, results: RMap[F, Result]) = ()
} }
} }