mirror of https://github.com/sbt/sbt.git
64 lines
2.4 KiB
Scala
64 lines
2.4 KiB
Scala
package xsbt
|
|
|
|
import sbinary.{CollectionTypes, Format, JavaFormats}
|
|
import java.io.File
|
|
import scala.reflect.Manifest
|
|
|
|
trait Cache[I,O]
|
|
{
|
|
def apply(file: File)(i: I): Either[O, O => Unit]
|
|
}
|
|
trait SBinaryFormats extends CollectionTypes with JavaFormats with NotNull
|
|
{
|
|
//TODO: add basic types from SBinary minus FileFormat
|
|
}
|
|
object Cache extends BasicCacheImplicits with SBinaryFormats with HListCacheImplicits
|
|
{
|
|
def cache[I,O](implicit c: Cache[I,O]): Cache[I,O] = c
|
|
def outputCache[O](implicit c: OutputCache[O]): OutputCache[O] = c
|
|
def inputCache[O](implicit c: InputCache[O]): InputCache[O] = c
|
|
|
|
def wrapInputCache[I,DI](implicit convert: I => DI, base: InputCache[DI]): InputCache[I] =
|
|
new WrappedInputCache(convert, base)
|
|
def wrapOutputCache[O,DO](implicit convert: O => DO, reverse: DO => O, base: OutputCache[DO]): OutputCache[O] =
|
|
new WrappedOutputCache[O,DO](convert, reverse, base)
|
|
|
|
def apply[I,O](file: File)(f: I => Task[O])(implicit cache: Cache[I,O]): I => Task[O] =
|
|
in =>
|
|
cache(file)(in) match
|
|
{
|
|
case Left(value) => Task(value)
|
|
case Right(store) => f(in) map { out => store(out); out }
|
|
}
|
|
def cached[I,O](file: File)(f: I => O)(implicit cache: Cache[I,O]): I => O =
|
|
in =>
|
|
cache(file)(in) match
|
|
{
|
|
case Left(value) => value
|
|
case Right(store) =>
|
|
val out = f(in)
|
|
store(out)
|
|
out
|
|
}
|
|
}
|
|
trait BasicCacheImplicits extends NotNull
|
|
{
|
|
implicit def basicInputCache[I](implicit format: Format[I], equiv: Equiv[I]): InputCache[I] =
|
|
new BasicInputCache(format, equiv)
|
|
implicit def basicOutputCache[O](implicit format: Format[O]): OutputCache[O] =
|
|
new BasicOutputCache(format)
|
|
|
|
implicit def ioCache[I,O](implicit input: InputCache[I], output: OutputCache[O]): Cache[I,O] =
|
|
new SeparatedCache(input, output)
|
|
implicit def defaultEquiv[T]: Equiv[T] = new Equiv[T] { def equiv(a: T, b: T) = a == b }
|
|
}
|
|
trait HListCacheImplicits extends HLists
|
|
{
|
|
implicit def hConsInputCache[H,T<:HList](implicit headCache: InputCache[H], tailCache: InputCache[T]): InputCache[HCons[H,T]] =
|
|
new HConsInputCache(headCache, tailCache)
|
|
implicit lazy val hNilInputCache: InputCache[HNil] = new HNilInputCache
|
|
|
|
implicit def hConsOutputCache[H,T<:HList](implicit headCache: OutputCache[H], tailCache: OutputCache[T]): OutputCache[HCons[H,T]] =
|
|
new HConsOutputCache(headCache, tailCache)
|
|
implicit lazy val hNilOutputCache: OutputCache[HNil] = new HNilOutputCache
|
|
} |