mirror of https://github.com/sbt/sbt.git
56 lines
2.2 KiB
Scala
56 lines
2.2 KiB
Scala
package xsbt
|
|
|
|
import java.io.File
|
|
import scala.collection.mutable.{HashMap, Map, MultiMap, Set}
|
|
import scala.reflect.Manifest
|
|
import sbinary.{DefaultProtocol, Format}
|
|
import DefaultProtocol._
|
|
import TrackingFormat._
|
|
import CacheIO.{fromFile, toFile}
|
|
import DependencyTracking.{DependencyMap => DMap, newMap, TagMap}
|
|
|
|
private class TrackingFormat[T](directory: File, translateProducts: Boolean)(implicit tFormat: Format[T], mf: Manifest[T]) extends NotNull
|
|
{
|
|
val indexFile = new File(directory, "index")
|
|
val dependencyFile = new File(directory, "dependencies")
|
|
def read(): DependencyTracking[T] =
|
|
{
|
|
val indexMap = CacheIO.fromFile[Map[Int,T]](indexFile, new HashMap[Int,T])
|
|
val indexedFormat = wrap[T,Int](ignore => error("Read-only"), i => indexMap.getOrElse(i, error("Index " + i + " not found")))
|
|
val trackFormat = trackingFormat(translateProducts)(indexedFormat)
|
|
fromFile(trackFormat, DefaultTracking[T](translateProducts))(dependencyFile)
|
|
}
|
|
def write(tracking: DependencyTracking[T])
|
|
{
|
|
val index = new IndexMap[T]
|
|
val indexedFormat = wrap[T,Int](t => index(t), ignore => error("Write-only"))
|
|
val trackFormat = trackingFormat(translateProducts)(indexedFormat)
|
|
toFile(trackFormat)(tracking)(dependencyFile)
|
|
toFile(index.indices)(indexFile)
|
|
}
|
|
}
|
|
private object TrackingFormat
|
|
{
|
|
implicit def mutableMapFormat[S, T](implicit binS : Format[S], binT : Format[T]) : Format[Map[S, T]] =
|
|
viaArray( (x : Array[(S, T)]) => Map(x :_*));
|
|
implicit def depMapFormat[T](implicit bin: Format[T]) : Format[DMap[T]] =
|
|
{
|
|
viaArray { (x : Array[(T, Set[T])]) =>
|
|
val map = newMap[T]
|
|
map ++= x
|
|
map
|
|
}
|
|
}
|
|
def trackingFormat[T](translateProducts: Boolean)(implicit tFormat: Format[T]): Format[DependencyTracking[T]] =
|
|
asProduct4((a: DMap[T],b: DMap[T],c: DMap[T], d:TagMap[T]) => new DefaultTracking(translateProducts)(a,b,c,d) : DependencyTracking[T]
|
|
)(dt => Some(dt.reverseDependencies, dt.reverseUses, dt.sourceMap, dt.tagMap))
|
|
}
|
|
|
|
private final class IndexMap[T] extends NotNull
|
|
{
|
|
private[this] var lastIndex = 0
|
|
private[this] val map = new HashMap[T, Int]
|
|
private[this] def nextIndex = { lastIndex += 1; lastIndex }
|
|
def indices = HashMap(map.map( (_: (T,Int)).swap ).toSeq : _*)
|
|
def apply(t: T) = map.getOrElseUpdate(t, nextIndex)
|
|
} |