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

allow homogeneous inputs in addition to heterogeneous inputs (Node)

This commit is contained in:
Mark Harrah 2010-06-10 08:17:51 -04:00
parent d6626e1e11
commit 647a78467e
2 changed files with 22 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
tasks/Execute.scala
View File

@ -5,7 +5,6 @@ package sbt
// TODO: Incomplete needs to be parameterized with A[_] and have val node
import Node._
import Types._
import Execute._
@ -87,13 +86,21 @@ final class Execute[A[_] <: AnyRef](checkCycles: Boolean)(implicit view: A ~> No
readyInv( node )
}
state(node) = Calling
addChecked(target)
addCaller(node, target)
results.get(target) match {
case Some(result) => retire(node, result)
case None =>
state(node) = Calling
addChecked(target)
addCaller(node, target)
}
post {
assert( calling(node) )
assert( callers(target) contains node )
if(done(target))
assert(done(node))
else {
assert(calling(node) )
assert( callers(target) contains node )
}
readyInv( node )
}
}
@ -200,8 +207,8 @@ final class Execute[A[_] <: AnyRef](checkCycles: Boolean)(implicit view: A ~> No
def submit[T]( node: A[T] )(implicit strategy: Strategy)
{
val v = view(node)
val rs: v.Inputs#Map[Result] = v.inputs.map(results)
val ud = v.unitDependencies.flatMap(incomplete)
val rs: v.Mixed#Map[Result] = v.mixedIn.map(results)
val ud = v.uniformIn.map(results.apply[v.Uniform])
strategy.submit( node, () => work(node, v.work(rs, ud)) )
}
/** Evaluates the computation 'f' for 'node'.
@ -229,7 +236,7 @@ final class Execute[A[_] <: AnyRef](checkCycles: Boolean)(implicit view: A ~> No
def addCaller[T](caller: A[T], target: A[T]): Unit = callers.getOrUpdate(target, IDSet.create[A[T]]) += caller
def dependencies(node: A[_]): Iterable[A[_]] = dependencies(view(node))
def dependencies(v: Node[A, _]): Iterable[A[_]] = v.unitDependencies ++ v.inputs.toList
def dependencies(v: Node[A, _]): Iterable[A[_]] = v.uniformIn ++ v.mixedIn.toList
// Contracts

29
tasks/Node.scala
View File

@ -3,33 +3,16 @@
*/
package sbt
import Node._
import Types._
trait Node[A[_], T]
{
type Inputs <: MList[A]
type Results = Inputs#Map[Result]
type Mixed <: MList[A]
type MixedResults = Mixed#Map[Result]
type Uniform
val inputs: Inputs
def unitDependencies: Iterable[A[_]]
val mixedIn: Mixed
val uniformIn: Seq[A[Uniform]]
def work(results: Results, units: UnitResults[A]): Either[A[T], T]
}
object Node
{
/*def pure[T](f: () => T): PureNode[T]= map[Id, T, MNil](MNil, Nil)((_,_) => f() )
def map[A[_], T, Inputs0 <: MList[A]](inputs0: Inputs0, deps0: Iterable[A[_]])(work0: (Inputs0#Map[Result], UnitResults[A]) => T):
Node[A,T] { type Inputs = Inputs0 } =
new Node[A,T] {
type Inputs = Inputs0
val inputs = inputs0
def unitDependencies = deps0
def work(results: Results, units: UnitResults[A]) = Right(work0(results, units))
}
type PureNode[T] = Node[Id, T] { type Inputs = MNil; type Results = MNil }*/
type UnitResults[A[_]] = Iterable[(A[_], Incomplete)]
def work(mixed: MixedResults, uniform: Seq[Result[Uniform]]): Either[A[T], T]
}