package duration
- Alphabetic
- By Inheritance
- duration
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
- 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
andtimeLeft
. All durations are measured according toSystem.nanoTime
; this does not take into account changes to the system clock (such as leap seconds). - implicit final class DoubleMult extends AnyVal
- 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.
- trait DurationConversions extends Any
- implicit final class DurationDouble extends AnyVal with DurationConversions
- implicit final class DurationInt extends AnyVal with DurationConversions
- implicit final class DurationLong extends AnyVal with DurationConversions
- 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.
- implicit final class IntMult extends AnyVal
- implicit final class LongMult extends AnyVal
- type TimeUnit = java.util.concurrent.TimeUnit
Value Members
- final val DAYS: java.util.concurrent.TimeUnit(DAYS)
- final val HOURS: java.util.concurrent.TimeUnit(HOURS)
- final val MICROSECONDS: java.util.concurrent.TimeUnit(MICROSECONDS)
- final val MILLISECONDS: java.util.concurrent.TimeUnit(MILLISECONDS)
- final val MINUTES: java.util.concurrent.TimeUnit(MINUTES)
- final val NANOSECONDS: java.util.concurrent.TimeUnit(NANOSECONDS)
- final val SECONDS: java.util.concurrent.TimeUnit(SECONDS)
- implicit def durationToPair(d: Duration): (Long, TimeUnit)
- implicit def pairIntToDuration(p: (Int, TimeUnit)): Duration
- implicit def pairLongToDuration(p: (Long, TimeUnit)): FiniteDuration
- object Deadline extends java.io.Serializable
- object Duration extends java.io.Serializable
- object DurationConversions
This object just holds some cogs which make the DSL machine work, not for direct consumption.
- object FiniteDuration extends java.io.Serializable
- 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
- 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
This is the documentation for the Scala standard library.
Package structure
The scala package contains core types like
Int
,Float
,Array
orOption
which are accessible in all Scala compilation units without explicit qualification or imports.Notable packages include:
scala.collection
and its sub-packages contain Scala's collections frameworkscala.collection.immutable
- Immutable, sequential data-structures such asVector
,List
,Range
,HashMap
orHashSet
scala.collection.mutable
- Mutable, sequential data-structures such asArrayBuffer
,StringBuilder
,HashMap
orHashSet
scala.collection.concurrent
- Mutable, concurrent data-structures such asTrieMap
scala.concurrent
- Primitives for concurrent programming such asFutures
andPromises
scala.io
- Input and output operationsscala.math
- Basic math functions and additional numeric types likeBigInt
andBigDecimal
scala.sys
- Interaction with other processes and the operating systemscala.util.matching
- Regular expressionsOther packages exist. See the complete list on the right.
Additional parts of the standard library are shipped as separate libraries. These include:
scala.reflect
- Scala's reflection API (scala-reflect.jar)scala.xml
- XML parsing, manipulation, and serialization (scala-xml.jar)scala.collection.parallel
- Parallel collections (scala-parallel-collections.jar)scala.util.parsing
- Parser combinators (scala-parser-combinators.jar)scala.swing
- A convenient wrapper around Java's GUI framework called Swing (scala-swing.jar)Automatic imports
Identifiers in the scala package and the
scala.Predef
object are always in scope by default.Some of these identifiers are type aliases provided as shortcuts to commonly used classes. For example,
List
is an alias forscala.collection.immutable.List
.Other aliases refer to classes provided by the underlying platform. For example, on the JVM,
String
is an alias forjava.lang.String
.