scala.concurrent

# duration

#### package duration

Source
  package.scala

Linear Supertypes
AnyRef, Any
Content Hierarchy Learn more about scaladoc diagrams
Ordering

1. Alphabetic
2. By inheritance

Inherited

1. duration
2. AnyRef
3. Any

1. Hide All
2. Show all

Learn more about member selection
Visibility

1. Public
2. All

### Type Members

1. #### case class Deadline extends Ordered[Deadline] with Product with Serializable

   This class stores a deadline, as obtained via `Deadline.now` or the duration DSL:

   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).

2. #### implicit final class DoubleMult extends AnyVal

3. #### sealed abstract class Duration extends Serializable with Ordered[Duration]

   This class is not meant as a general purpose representation of time, it is optimized for the needs of `scala.concurrent`.

   #### Utility for working with java.util.concurrent.TimeUnit durations.

   This class is not meant as a general purpose representation of time, it is optimized for the needs of `scala.concurrent`.

   #### Basic Usage

   Examples:

       import scala.concurrent.duration._

       val duration = Duration(100, MILLISECONDS)
       val duration = Duration(100, "millis")

       duration.toNanos
       duration < 1.second
       duration <= Duration.Inf

   Invoking inexpressible conversions (like calling `toSeconds` on an infinite duration) will throw an IllegalArgumentException.

   Implicits are also provided for Int, Long and Double. Example usage:

       import scala.concurrent.duration._

       val duration = 100 millis

   The DSL provided by the implicit conversions always allows construction of finite durations, even for infinite Double inputs; use Duration.Inf instead.

   Extractors, parsing and arithmetic are also included:

       val d = Duration("1.2 ￂﾵs")
       val Duration(length, unit) = 5 millis
       val d2 = d * 2.5
       val d3 = d2 + 1.millisecond

   #### Handling of Time Units

   Calculations performed on finite durations always retain the more precise unit of either operand, no matter whether a coarser unit would be able to exactly express the same duration. This means that Duration can be used as a lossless container for a (length, unit) pair if it is constructed using the corresponding methods and no arithmetic is performed on it; adding/subtracting durations should in that case be done with care.

   #### Correspondence to Double Semantics

   The semantics of arithmetic operations on Duration are two-fold:

   - exact addition/subtraction with nanosecond resolution for finite durations, independent of the summands' magnitude
   - isomorphic to `java.lang.Double` when it comes to infinite or undefined values

   The conversion between Duration and Double is done using Duration.toUnit (with unit NANOSECONDS) and Duration.fromNanos(Double).

   #### Ordering

   The default ordering is consistent with the ordering of Double numbers, which means that Undefined is considered greater than all other durations, including Duration.Inf.

4. #### trait DurationConversions extends Any

5. #### implicit final class DurationDouble extends AnyVal with DurationConversions

6. #### implicit final class DurationInt extends AnyVal with DurationConversions

7. #### implicit final class DurationLong extends AnyVal with DurationConversions

8. #### final class FiniteDuration extends Duration

   This class represents a finite duration.

   This class represents a finite duration. Its addition and subtraction operators are overloaded to retain this guarantee statically. The range of this class is limited to +-(2^63-1)ns, which is roughly 292 years.

9. #### implicit final class IntMult extends AnyVal

10. #### implicit final class LongMult extends AnyVal

11. #### type TimeUnit = java.util.concurrent.TimeUnit

### Value Members

1. #### final val DAYS: java.util.concurrent.TimeUnit(DAYS)

2. #### object Deadline extends Serializable

3. #### object Duration extends Serializable

4. #### object DurationConversions

   This object just holds some cogs which make the DSL machine work, not for direct consumption.

5. #### object FiniteDuration extends Serializable

6. #### final val HOURS: java.util.concurrent.TimeUnit(HOURS)

7. #### final val MICROSECONDS: java.util.concurrent.TimeUnit(MICROSECONDS)

8. #### final val MILLISECONDS: java.util.concurrent.TimeUnit(MILLISECONDS)

9. #### final val MINUTES: java.util.concurrent.TimeUnit(MINUTES)

10. #### final val NANOSECONDS: java.util.concurrent.TimeUnit(NANOSECONDS)

11. #### final val SECONDS: java.util.concurrent.TimeUnit(SECONDS)

12. #### implicit def durationToPair(d: Duration): (Long, TimeUnit)

13. #### object fromNow

    This object can be used as closing token for declaring a deadline at some future point in time:

    This object can be used as closing token for declaring a deadline at some future point in time:

        import scala.concurrent.duration._

        val deadline = 3 seconds fromNow

14. #### implicit def pairIntToDuration(p: (Int, TimeUnit)): Duration

15. #### implicit def pairLongToDuration(p: (Long, TimeUnit)): FiniteDuration

16. #### object span

    This object can be used as closing token if you prefer dot-less style but do not want to enable language.postfixOps:

    This object can be used as closing token if you prefer dot-less style but do not want to enable language.postfixOps:

        import scala.concurrent.duration._

        val duration = 2 seconds span

### Inherited from AnyRef

### Inherited from Any

### Ungrouped