Moving Duration DSL to a separate package.

Reverting to Java 6 time units.

Review by: @phaller

4 files changed, 121 insertions, 110 deletions

diff --git a/src/library/scala/concurrent/util/Duration.scala b/src/library/scala/concurrent/util/Duration.scala
index 33d034da76..6ee1696d39 100644
--- a/src/library/scala/concurrent/util/Duration.scala
+++ b/src/library/scala/concurrent/util/Duration.scala
@@ -8,51 +8,6 @@ import java.util.concurrent.TimeUnit
 import TimeUnit._
 import java.lang.{ Double ⇒ JDouble }
 
-object DurationImplicits {
-  trait Classifier[C] {
-    type R
-    def convert(d: FiniteDuration): R
-  }
-
-  object span
-  implicit object spanConvert extends Classifier[span.type] {
-    type R = FiniteDuration
-    def convert(d: FiniteDuration) = d
-  }
-
-  object fromNow
-  implicit object fromNowConvert extends Classifier[fromNow.type] {
-    type R = Deadline
-    def convert(d: FiniteDuration) = Deadline.now + d
-  }
-
-  implicit def intToDurationInt(n: Int) = new DurationInt(n)
-  implicit def longToDurationLong(n: Long) = new DurationLong(n)
-  implicit def doubleToDurationDouble(d: Double) = new DurationDouble(d)
-
-  implicit def pairIntToDuration(p: (Int, TimeUnit)) = Duration(p._1, p._2)
-  implicit def pairLongToDuration(p: (Long, TimeUnit)) = Duration(p._1, p._2)
-  implicit def durationToPair(d: Duration) = (d.length, d.unit)
-
-  /*
-   * Avoid reflection based invocation by using non-duck type
-   */
-  class IntMult(i: Int) {
-    def *(d: Duration) = d * i
-  }
-  implicit def intMult(i: Int) = new IntMult(i)
-
-  class LongMult(l: Long) {
-    def *(d: Duration) = d * l
-  }
-  implicit def longMult(l: Long) = new LongMult(l)
-
-  class DoubleMult(f: Double) {
-    def *(d: Duration) = d * f
-  }
-  implicit def doubleMult(f: Double) = new DoubleMult(f)
-}
-
 case class Deadline private (time: Duration) {
   def +(other: Duration): Deadline = copy(time = time + other)
   def -(other: Duration): Deadline = copy(time = time - other)
@@ -71,10 +26,7 @@ object Duration {
 
   def apply(length: Long, unit: TimeUnit): FiniteDuration = new FiniteDuration(length, unit)
   def apply(length: Double, unit: TimeUnit): FiniteDuration = fromNanos(unit.toNanos(1) * length)
-  def apply(length: Long, unit: String): FiniteDuration = {
-    val (mult, timeUnit) = Duration.timeUnit(unit)
-    new FiniteDuration(length * mult, timeUnit)
-  }
+  def apply(length: Long, unit: String): FiniteDuration = new FiniteDuration(length,  Duration.timeUnit(unit))
 
   /**
    * Construct a Duration by parsing a String. In case of a format error, a
@@ -117,11 +69,11 @@ object Duration {
   def unapply(s: String): Option[Duration] = s match {
     case RE(length, d, h, m, s, ms, mus, ns) ⇒
       if (d ne null)
-        Some(Duration(JDouble.parseDouble(length) * 86400, SECONDS))
+        Some(Duration(JDouble.parseDouble(length), DAYS))
       else if (h ne null)
-        Some(Duration(JDouble.parseDouble(length) * 3600, SECONDS))
+        Some(Duration(JDouble.parseDouble(length), HOURS))
       else if (m ne null)
-        Some(Duration(JDouble.parseDouble(length) * 60, SECONDS))
+        Some(Duration(JDouble.parseDouble(length), MINUTES))
       else if (s ne null)
         Some(Duration(JDouble.parseDouble(length), SECONDS))
       else if (ms ne null)
@@ -142,11 +94,11 @@ object Duration {
 
   def fromNanos(nanos: Long): FiniteDuration = {
     if (nanos % 86400000000000L == 0) {
-      Duration(nanos / 1000000000L, SECONDS)
-    } else if (nanos % 1000000000L == 0) {
-      Duration(nanos / 1000000000L, SECONDS)
-    } else if (nanos % 1000000000L == 0) {
-      Duration(nanos / 1000000000L, SECONDS)
+      Duration(nanos / 86400000000000L, DAYS)
+    } else if (nanos % 3600000000000L == 0) {
+      Duration(nanos / 3600000000000L, HOURS)
+    } else if (nanos % 60000000000L == 0) {
+      Duration(nanos / 60000000000L, MINUTES)
     } else if (nanos % 1000000000L == 0) {
       Duration(nanos / 1000000000L, SECONDS)
     } else if (nanos % 1000000L == 0) {
@@ -161,14 +113,14 @@ object Duration {
   /**
    * Parse TimeUnit from string representation.
    */
-  protected[util] def timeUnit(unit: String): (Long, TimeUnit) = unit.toLowerCase match {
-    case "d" | "day" | "days"                                       ⇒ (86400, SECONDS)
-    case "h" | "hour" | "hours"                                     ⇒ (3600, SECONDS)
-    case "min" | "minute" | "minutes"                               ⇒ (60, SECONDS)
-    case "s" | "sec" | "second" | "seconds"                         ⇒ (1, SECONDS)
-    case "ms" | "milli" | "millis" | "millisecond" | "milliseconds" ⇒ (1, MILLISECONDS)
-    case "µs" | "micro" | "micros" | "microsecond" | "microseconds" ⇒ (1, MICROSECONDS)
-    case "ns" | "nano" | "nanos" | "nanosecond" | "nanoseconds"     ⇒ (1, NANOSECONDS)
+  protected[util] def timeUnit(unit: String): TimeUnit = unit.toLowerCase match {
+    case "d" | "day" | "days"                                       ⇒ DAYS
+    case "h" | "hour" | "hours"                                     ⇒ HOURS
+    case "min" | "minute" | "minutes"                               ⇒ MINUTES
+    case "s" | "sec" | "second" | "seconds"                         ⇒ SECONDS
+    case "ms" | "milli" | "millis" | "millisecond" | "milliseconds" ⇒ MILLISECONDS
+    case "µs" | "micro" | "micros" | "microsecond" | "microseconds" ⇒ MICROSECONDS
+    case "ns" | "nano" | "nanos" | "nanosecond" | "nanoseconds"     ⇒ NANOSECONDS
   }
 
   val Zero: FiniteDuration = new FiniteDuration(0, NANOSECONDS)
@@ -328,13 +280,9 @@ object FiniteDuration {
     def compare(a: FiniteDuration, b: FiniteDuration) = a compare b
   }
 
-  def apply(length: Long, unit: TimeUnit) = 
-    new FiniteDuration(length, unit)
+  def apply(length: Long, unit: TimeUnit) = new FiniteDuration(length, unit)
 
-  def apply(length: Long, unit: String) = {
-    val (mult, timeUnit) = Duration.timeUnit(unit)
-    new FiniteDuration(length * mult, timeUnit)
-  }
+  def apply(length: Long, unit: String) = new FiniteDuration(length, Duration.timeUnit(unit))
 
 }
 
@@ -351,6 +299,12 @@ class FiniteDuration(val length: Long, val unit: TimeUnit) extends Duration {
   def toUnit(u: TimeUnit) = long2double(toNanos) / NANOSECONDS.convert(1, u)
 
   override def toString = this match {
+    case Duration(1, DAYS)         ⇒ "1 day"
+    case Duration(x, DAYS)         ⇒ x + " days"
+    case Duration(1, HOURS)        ⇒ "1 hour"
+    case Duration(x, HOURS)        ⇒ x + " hours"
+    case Duration(1, MINUTES)      ⇒ "1 minute"
+    case Duration(x, MINUTES)      ⇒ x + " minutes"
     case Duration(1, SECONDS)      ⇒ "1 second"
     case Duration(x, SECONDS)      ⇒ x + " seconds"
     case Duration(1, MILLISECONDS) ⇒ "1 millisecond"
@@ -404,7 +358,7 @@ class FiniteDuration(val length: Long, val unit: TimeUnit) extends Duration {
 }
 
 class DurationInt(n: Int) {
-  import DurationImplicits.Classifier
+  import duration.Classifier
 
   def nanoseconds = Duration(n, NANOSECONDS)
   def nanos = Duration(n, NANOSECONDS)
@@ -424,14 +378,14 @@ class DurationInt(n: Int) {
   def seconds = Duration(n, SECONDS)
   def second = Duration(n, SECONDS)
 
-  def minutes = Duration(n * 60, SECONDS)
-  def minute = Duration(n * 60, SECONDS)
+  def minutes = Duration(n, MINUTES)
+  def minute = Duration(n, MINUTES)
 
-  def hours = Duration(n * 3600, SECONDS)
-  def hour =  Duration(n * 3600, SECONDS)
+  def hours = Duration(n, HOURS)
+  def hour =  Duration(n, HOURS)
 
-  def days = Duration(n * 86400, SECONDS)
-  def day = Duration(n * 86400, SECONDS)
+  def days = Duration(n, DAYS)
+  def day = Duration(n, DAYS)
 
   def nanoseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, NANOSECONDS))
   def nanos[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, NANOSECONDS))
@@ -451,18 +405,18 @@ class DurationInt(n: Int) {
   def seconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, SECONDS))
   def second[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, SECONDS))
 
-  def minutes[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n * 60, SECONDS))
-  def minute[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n * 60, SECONDS))
+  def minutes[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MINUTES))
+  def minute[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MINUTES))
 
-  def hours[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n * 3600, SECONDS))
-  def hour[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n * 3600, SECONDS))
+  def hours[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, HOURS))
+  def hour[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, HOURS))
 
-  def days[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n * 86400, SECONDS))
-  def day[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n * 86400, SECONDS))
+  def days[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, DAYS))
+  def day[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, DAYS))
 }
 
 class DurationLong(n: Long) {
-  import DurationImplicits.Classifier
+  import duration.Classifier
 
   def nanoseconds = Duration(n, NANOSECONDS)
   def nanos = Duration(n, NANOSECONDS)
@@ -482,14 +436,14 @@ class DurationLong(n: Long) {
   def seconds = Duration(n, SECONDS)
   def second = Duration(n, SECONDS)
 
-  def minutes = Duration(n * 60, SECONDS)
-  def minute = Duration(n * 60, SECONDS)
+  def minutes = Duration(n, MINUTES)
+  def minute = Duration(n, MINUTES)
 
-  def hours = Duration(n * 3600, SECONDS)
-  def hour = Duration(n * 3600, SECONDS)
+  def hours = Duration(n, HOURS)
+  def hour = Duration(n, HOURS)
 
-  def days = Duration(n * 86400, SECONDS)
-  def day = Duration(n * 86400, SECONDS)
+  def days = Duration(n, DAYS)
+  def day = Duration(n, DAYS)
 
   def nanoseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, NANOSECONDS))
   def nanos[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, NANOSECONDS))
@@ -509,18 +463,18 @@ class DurationLong(n: Long) {
   def seconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, SECONDS))
   def second[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, SECONDS))
 
-  def minutes[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n * 60, SECONDS))
-  def minute[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n * 60, SECONDS))
+  def minutes[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MINUTES))
+  def minute[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MINUTES))
 
-  def hours[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n * 3600, SECONDS))
-  def hour[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n * 3600, SECONDS))
+  def hours[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, HOURS))
+  def hour[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, HOURS))
 
-  def days[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n * 86400, SECONDS))
-  def day[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n * 86400, SECONDS))
+  def days[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, DAYS))
+  def day[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, DAYS))
 }
 
 class DurationDouble(d: Double) {
-  import DurationImplicits.Classifier
+  import duration.Classifier
 
   def nanoseconds = Duration(d, NANOSECONDS)
   def nanos = Duration(d, NANOSECONDS)
@@ -540,14 +494,14 @@ class DurationDouble(d: Double) {
   def seconds = Duration(d, SECONDS)
   def second = Duration(d, SECONDS)
 
-  def minutes = Duration(d * 60, SECONDS)
-  def minute = Duration(d * 60, SECONDS)
+  def minutes = Duration(d, MINUTES)
+  def minute = Duration(d, MINUTES)
 
-  def hours = Duration(d * 3600, SECONDS)
-  def hour = Duration(d * 3600, SECONDS)
+  def hours = Duration(d, HOURS)
+  def hour = Duration(d, HOURS)
 
-  def days = Duration(d * 86400, SECONDS)
-  def day = Duration(d * 86400, SECONDS)
+  def days = Duration(d, DAYS)
+  def day = Duration(d, DAYS)
 
   def nanoseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, NANOSECONDS))
   def nanos[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, NANOSECONDS))
@@ -567,12 +521,12 @@ class DurationDouble(d: Double) {
   def seconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, SECONDS))
   def second[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, SECONDS))
 
-  def minutes[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d * 60, SECONDS))
-  def minute[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d * 60, SECONDS))
+  def minutes[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, MINUTES))
+  def minute[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, MINUTES))
 
-  def hours[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d * 3600, SECONDS))
-  def hour[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d * 3600, SECONDS))
+  def hours[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, HOURS))
+  def hour[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, HOURS))
 
-  def days[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d * 86400, SECONDS))
-  def day[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d * 86400, SECONDS))
+  def days[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, DAYS))
+  def day[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, DAYS))
 }
diff --git a/src/library/scala/concurrent/util/duration/Classifier.scala b/src/library/scala/concurrent/util/duration/Classifier.scala
new file mode 100644
index 0000000000..10faf0a5ce
--- /dev/null
+++ b/src/library/scala/concurrent/util/duration/Classifier.scala
@@ -0,0 +1,9 @@
+package scala.concurrent.util.duration
+
+import scala.concurrent.util.{ FiniteDuration }
+
+trait Classifier[C] {
+  type R
+  def convert(d: FiniteDuration): R
+}
+
diff --git a/src/library/scala/concurrent/util/duration/NumericMultiplication.scala b/src/library/scala/concurrent/util/duration/NumericMultiplication.scala
new file mode 100644
index 0000000000..94c58fb8c2
--- /dev/null
+++ b/src/library/scala/concurrent/util/duration/NumericMultiplication.scala
@@ -0,0 +1,18 @@
+package scala.concurrent.util.duration
+
+import scala.concurrent.util.{ Duration }
+
+/*
+ * Avoid reflection based invocation by using non-duck type
+ */
+protected[duration] class IntMult(i: Int) {
+  def *(d: Duration) = d * i
+}
+
+protected[duration] class LongMult(i: Long) {
+  def *(d: Duration) = d * i
+}
+
+protected[duration] class DoubleMult(f: Double) {
+  def *(d: Duration) = d * f
+}
diff --git a/src/library/scala/concurrent/util/duration/package.scala b/src/library/scala/concurrent/util/duration/package.scala
new file mode 100644
index 0000000000..25625054ee
--- /dev/null
+++ b/src/library/scala/concurrent/util/duration/package.scala
@@ -0,0 +1,30 @@
+package scala.concurrent.util
+
+import java.util.concurrent.TimeUnit
+
+package object duration {
+
+  object span
+  implicit object spanConvert extends Classifier[span.type] {
+    type R = FiniteDuration
+    def convert(d: FiniteDuration) = d
+  }
+
+  object fromNow
+  implicit object fromNowConvert extends Classifier[fromNow.type] {
+    type R = Deadline
+    def convert(d: FiniteDuration) = Deadline.now + d
+  }
+
+  implicit def intToDurationInt(n: Int) = new DurationInt(n)
+  implicit def longToDurationLong(n: Long) = new DurationLong(n)
+  implicit def doubleToDurationDouble(d: Double) = new DurationDouble(d)
+
+  implicit def pairIntToDuration(p: (Int, TimeUnit)) = Duration(p._1, p._2)
+  implicit def pairLongToDuration(p: (Long, TimeUnit)) = Duration(p._1, p._2)
+  implicit def durationToPair(d: Duration) = (d.length, d.unit)
+
+  implicit def intMult(i: Int) = new IntMult(i)
+  implicit def longMult(l: Long) = new LongMult(l)
+  implicit def doubleMult(f: Double) = new DoubleMult(f)
+}
\ No newline at end of file