blob: 61cbe4753072a3864c1998b76d465988de59e65c (
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
|
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2003-2013, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
package scala.concurrent.duration
/**
* This class stores a deadline, as obtained via `Deadline.now` or the
* duration DSL:
*
* {{{
* import scala.concurrent.duration._
* 3.seconds.fromNow
* }}}
*
* Its main purpose is to manage repeated attempts to achieve something (like
* awaiting a condition) by offering the methods `hasTimeLeft` and `timeLeft`. All
* durations are measured according to `System.nanoTime` aka wall-time; this
* does not take into account changes to the system clock (such as leap
* seconds).
*/
case class Deadline private (time: FiniteDuration) extends Ordered[Deadline] {
/**
* Return a deadline advanced (i.e. moved into the future) by the given duration.
*/
def +(other: FiniteDuration): Deadline = copy(time = time + other)
/**
* Return a deadline moved backwards (i.e. towards the past) by the given duration.
*/
def -(other: FiniteDuration): Deadline = copy(time = time - other)
/**
* Calculate time difference between this and the other deadline, where the result is directed (i.e. may be negative).
*/
def -(other: Deadline): FiniteDuration = time - other.time
/**
* Calculate time difference between this duration and now; the result is negative if the deadline has passed.
*
* '''''Note that on some systems this operation is costly because it entails a system call.'''''
* Check `System.nanoTime` for your platform.
*/
def timeLeft: FiniteDuration = this - Deadline.now
/**
* Determine whether the deadline still lies in the future at the point where this method is called.
*
* '''''Note that on some systems this operation is costly because it entails a system call.'''''
* Check `System.nanoTime` for your platform.
*/
def hasTimeLeft(): Boolean = !isOverdue()
/**
* Determine whether the deadline lies in the past at the point where this method is called.
*
* '''''Note that on some systems this operation is costly because it entails a system call.'''''
* Check `System.nanoTime` for your platform.
*/
def isOverdue(): Boolean = (time.toNanos - System.nanoTime()) < 0
/**
* The natural ordering for deadline is determined by the natural order of the underlying (finite) duration.
*/
def compare(other: Deadline) = time compare other.time
}
object Deadline {
/**
* Construct a deadline due exactly at the point where this method is called. Useful for then
* advancing it to obtain a future deadline, or for sampling the current time exactly once and
* then comparing it to multiple deadlines (using subtraction).
*/
def now: Deadline = Deadline(Duration(System.nanoTime, NANOSECONDS))
/**
* The natural ordering for deadline is determined by the natural order of the underlying (finite) duration.
*/
implicit object DeadlineIsOrdered extends Ordering[Deadline] {
def compare(a: Deadline, b: Deadline) = a compare b
}
}
|
