From 34df04c37806d1969c5bad994fcf0bbd137dbf74 Mon Sep 17 00:00:00 2001 From: Mark Harrah Date: Sat, 4 Sep 2010 08:07:51 -0400 Subject: [PATCH] cleanup --- cache/tracking/DependencyTracking.scala | 136 ------------------------ cache/tracking/TrackingFormat.scala | 65 ----------- 2 files changed, 201 deletions(-) delete mode 100644 cache/tracking/DependencyTracking.scala delete mode 100644 cache/tracking/TrackingFormat.scala diff --git a/cache/tracking/DependencyTracking.scala b/cache/tracking/DependencyTracking.scala deleted file mode 100644 index 30e060af3..000000000 --- a/cache/tracking/DependencyTracking.scala +++ /dev/null @@ -1,136 +0,0 @@ -/* sbt -- Simple Build Tool - * Copyright 2009, 2010 Mark Harrah - */ -package sbt - -private object DependencyTracking -{ - import scala.collection.mutable.{Set, HashMap, Map, MultiMap} - type DependencyMap[T] = HashMap[T, Set[T]] with MultiMap[T, T] - def newMap[T]: DependencyMap[T] = new HashMap[T, Set[T]] with MultiMap[T, T] - type TagMap[T] = Map[T, Array[Byte]] - def newTagMap[T] = new HashMap[T, Array[Byte]] -} - -trait UpdateTracking[T] extends NotNull -{ - def dependency(source: T, dependsOn: T): Unit - def use(source: T, uses: T): Unit - def product(source: T, output: T): Unit - def tag(source: T, t: Array[Byte]): Unit - def read: ReadTracking[T] - // removes files from all maps, both keys and values - def removeAll(files: Iterable[T]): Unit - // removes sources as keys/values in source, product maps and as values in reverseDependencies map - def pending(sources: Iterable[T]): Unit -} -trait ReadTracking[T] extends NotNull -{ - def isProduct(file: T): Boolean - def isSource(file: T): Boolean - def isUsed(file: T): Boolean - def dependsOn(file: T): Set[T] - def products(file: T): Set[T] - def sources(file: T): Set[T] - def usedBy(file: T): Set[T] - def tag(file: T): Array[Byte] - def allProducts: Set[T] - def allSources: Set[T] - def allUsed: Set[T] - def allTags: Seq[(T,Array[Byte])] -} -import DependencyTracking.{DependencyMap => DMap, newMap, newTagMap, TagMap} -private object DefaultTracking -{ - def apply[T](translateProducts: Boolean): DependencyTracking[T] = - new DefaultTracking(translateProducts)(newMap, newMap, newMap, newTagMap) -} -private final class DefaultTracking[T](translateProducts: Boolean) - (val reverseDependencies: DMap[T], val reverseUses: DMap[T], val sourceMap: DMap[T], val tagMap: TagMap[T]) - extends DependencyTracking[T](translateProducts) -{ - val productMap: DMap[T] = forward(sourceMap) // map from a source to its products. Keep in sync with sourceMap -} -// if translateProducts is true, dependencies on a product are translated to dependencies on a source -// if there is a source recorded as generating that product -private abstract class DependencyTracking[T](translateProducts: Boolean) extends ReadTracking[T] with UpdateTracking[T] -{ - val reverseDependencies: DMap[T] // map from a file to the files that depend on it - val reverseUses: DMap[T] // map from a file to the files that use it - val sourceMap: DMap[T] // map from a product to its sources. Keep in sync with productMap - val productMap: DMap[T] // map from a source to its products. Keep in sync with sourceMap - val tagMap: TagMap[T] - - def read = this - - final def dependsOn(file: T): Set[T] = get(reverseDependencies, file) - final def products(file: T): Set[T] = get(productMap, file) - final def sources(file: T): Set[T] = get(sourceMap, file) - final def usedBy(file: T): Set[T] = get(reverseUses, file) - final def tag(file: T): Array[Byte] = tagMap.getOrElse(file, new Array[Byte](0)) - - def isProduct(file: T): Boolean = exists(sourceMap, file) - def isSource(file: T): Boolean = exists(productMap, file) - def isUsed(file: T): Boolean = exists(reverseUses, file) - - - final def allProducts = sourceMap.keysIterator.toSet - final def allSources = productMap.keysIterator.toSet - final def allUsed = reverseUses.keysIterator.toSet - final def allTags = tagMap.toSeq - - private def exists(map: DMap[T], value: T): Boolean = map.contains(value) - private def get(map: DMap[T], value: T): Set[T] = map.getOrElse[collection.Set[T]](value, Set.empty[T]).toSet - - final def dependency(sourceFile: T, dependsOn: T) - { - val actualDependencies = - if(!translateProducts) - Seq(dependsOn) - else - sourceMap.getOrElse[Iterable[T]](dependsOn, Seq(dependsOn)) - actualDependencies.foreach { actualDependency => reverseDependencies.add(actualDependency, sourceFile) } - } - final def product(sourceFile: T, product: T) - { - productMap.add(sourceFile, product) - sourceMap.add(product, sourceFile) - } - final def use(sourceFile: T, usesFile: T) { reverseUses.add(usesFile, sourceFile) } - final def tag(sourceFile: T, t: Array[Byte]) { tagMap(sourceFile) = t } - - private def removeOneWay(a: DMap[T], files: Iterable[T]): Unit = - a.values.foreach { _ --= files } - private def remove(a: DMap[T], b: DMap[T], file: T): Unit = - for(x <- a.removeKey(file)) b --= x - private def removeAll(files: Iterable[T], a: DMap[T], b: DMap[T]): Unit = - files.foreach { file => remove(a, b, file); remove(b, a, file) } - final def removeAll(files: Iterable[T]) - { - removeAll(files, forward(reverseDependencies), reverseDependencies) - removeAll(files, productMap, sourceMap) - removeAll(files, forward(reverseUses), reverseUses) - tagMap --= files - } - def pending(sources: Iterable[T]) - { - removeOneWay(reverseDependencies, sources) - removeOneWay(reverseUses, sources) - removeAll(sources, productMap, sourceMap) - tagMap --= sources - } - protected final def forward(map: DMap[T]): DMap[T] = - { - val f = newMap[T] - for( (key, values) <- map; value <- values) f.add(value, key) - f - } - override def toString = - (graph("Reverse source dependencies", reverseDependencies) :: - graph("Sources and products", productMap) :: - graph("Reverse uses", reverseUses) :: - Nil) mkString "\n" - def graph(title: String, map: DMap[T]) = - "\"" + title + "\" {\n\t" + graphEntries(map) + "\n}" - def graphEntries(map: DMap[T]) = map.map{ case (key, values) => values.map(key + " -> " + _).mkString("\n\t") }.mkString("\n\t") -} diff --git a/cache/tracking/TrackingFormat.scala b/cache/tracking/TrackingFormat.scala deleted file mode 100644 index d8a5e0f2c..000000000 --- a/cache/tracking/TrackingFormat.scala +++ /dev/null @@ -1,65 +0,0 @@ -/* sbt -- Simple Build Tool - * Copyright 2009, 2010 Mark Harrah - */ -package sbt - -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[HashMap[S, T]] = - new LengthEncoded[HashMap[S, T], (S, T)] { - def build(size : Int, ts : Iterator[(S, T)]) : HashMap[S, T] = { - val b = new HashMap[S, T] - b ++= ts - b - } - } - implicit def depMapFormat[T](implicit bin: Format[T]) : Format[DMap[T]] = - new LengthEncoded[DMap[T], (T, Set[T])] { - def build(size : Int, ts : Iterator[(T, Set[T])]) : DMap[T] = { - val b = newMap[T] - b ++= ts - b - } - } - 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 => (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) -} \ No newline at end of file