blob: 74afa0ca1cddbc77624d2409bce3ae878a1253aa (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
|
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2003-2013, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
package scala.concurrent.duration
import DurationConversions._
// Would be nice to limit the visibility of this trait a little bit,
// but it crashes scalac to do so.
trait DurationConversions extends Any {
protected def durationIn(unit: TimeUnit): FiniteDuration
def nanoseconds = durationIn(NANOSECONDS)
def nanos = nanoseconds
def nanosecond = nanoseconds
def nano = nanoseconds
def microseconds = durationIn(MICROSECONDS)
def micros = microseconds
def microsecond = microseconds
def micro = microseconds
def milliseconds = durationIn(MILLISECONDS)
def millis = milliseconds
def millisecond = milliseconds
def milli = milliseconds
def seconds = durationIn(SECONDS)
def second = seconds
def minutes = durationIn(MINUTES)
def minute = minutes
def hours = durationIn(HOURS)
def hour = hours
def days = durationIn(DAYS)
def day = days
def nanoseconds[C](c: C)(implicit ev: Classifier[C]): ev.R = ev.convert(nanoseconds)
def nanos[C](c: C)(implicit ev: Classifier[C]): ev.R = nanoseconds(c)
def nanosecond[C](c: C)(implicit ev: Classifier[C]): ev.R = nanoseconds(c)
def nano[C](c: C)(implicit ev: Classifier[C]): ev.R = nanoseconds(c)
def microseconds[C](c: C)(implicit ev: Classifier[C]): ev.R = ev.convert(microseconds)
def micros[C](c: C)(implicit ev: Classifier[C]): ev.R = microseconds(c)
def microsecond[C](c: C)(implicit ev: Classifier[C]): ev.R = microseconds(c)
def micro[C](c: C)(implicit ev: Classifier[C]): ev.R = microseconds(c)
def milliseconds[C](c: C)(implicit ev: Classifier[C]): ev.R = ev.convert(milliseconds)
def millis[C](c: C)(implicit ev: Classifier[C]): ev.R = milliseconds(c)
def millisecond[C](c: C)(implicit ev: Classifier[C]): ev.R = milliseconds(c)
def milli[C](c: C)(implicit ev: Classifier[C]): ev.R = milliseconds(c)
def seconds[C](c: C)(implicit ev: Classifier[C]): ev.R = ev.convert(seconds)
def second[C](c: C)(implicit ev: Classifier[C]): ev.R = seconds(c)
def minutes[C](c: C)(implicit ev: Classifier[C]): ev.R = ev.convert(minutes)
def minute[C](c: C)(implicit ev: Classifier[C]): ev.R = minutes(c)
def hours[C](c: C)(implicit ev: Classifier[C]): ev.R = ev.convert(hours)
def hour[C](c: C)(implicit ev: Classifier[C]): ev.R = hours(c)
def days[C](c: C)(implicit ev: Classifier[C]): ev.R = ev.convert(days)
def day[C](c: C)(implicit ev: Classifier[C]): ev.R = days(c)
}
/**
* This object just holds some cogs which make the DSL machine work, not for direct consumption.
*/
object DurationConversions {
trait Classifier[C] {
type R
def convert(d: FiniteDuration): R
}
implicit object spanConvert extends Classifier[span.type] {
type R = FiniteDuration
def convert(d: FiniteDuration) = d
}
implicit object fromNowConvert extends Classifier[fromNow.type] {
type R = Deadline
def convert(d: FiniteDuration) = Deadline.now + d
}
}
|