CODEWITHSUNDEEP
scalaconfigdurationscala-java-interop
Jacob Eckel
Jacob Eckel

Reputation: 1641

Converting Java to Scala durations

Is there an elegant way to convert java.time.Duration to scala.concurrent.duration.FiniteDuration?

I am trying to do the following simple use of Config in Scala:

val d = ConfigFactory.load().getDuration("application.someTimeout")

However I don't see any simple way to use the result in Scala. Certainly hope the good people of Typesafe didn't expect me to do this:

FiniteDuration(d.getNano, TimeUnit.NANOSECONDS)

Edit: Note the line has a bug, which proves the point. See the selected answer below.

Upvotes: 63

Views: 24498

Answers (4)

Gabriele Petronella
Gabriele Petronella

Reputation: 108091

I don't know whether an explicit conversion is the only way, but if you want to do it right

FiniteDuration(d.toNanos, TimeUnit.NANOSECONDS)

toNanos will return the total duration, while getNano will only return the nanoseconds component, which is not what you want.

E.g.

import java.time.Duration
import jata.time.temporal.ChronoUnit
Duration.of(1, ChronoUnit.HOURS).getNano // 0
Duration.of(1, ChronoUnit.HOURS).toNanos  // 3600000000000L

That being said, you can also roll your own implicit conversion

implicit def asFiniteDuration(d: java.time.Duration) =
  scala.concurrent.duration.Duration.fromNanos(d.toNanos)

and when you have it in scope:

val d: FiniteDuration = ConfigFactory.load().getDuration("application.someTimeout")

Upvotes: 53

Stephen
Stephen

Reputation: 4296

There is a function for this in scala-java8-compat

in build.sbt

libraryDependencies += "org.scala-lang.modules" %% "scala-java8-compat" % "0.9.0"

import scala.compat.java8.DurationConverters._

val javaDuration: java.time.Duration = ???
val scalaDuration: FiniteDuration = javaDuration.toScala

Upvotes: 8

Xavier Guihot
Xavier Guihot

Reputation: 61646

Starting Scala 2.13, there is a dedicated DurationConverter from java's Duration to scala's FiniteDuration (and vice versa):

import scala.jdk.DurationConverters._

// val javaDuration = java.time.Duration.ofNanos(123456)
javaDuration.toScala
// scala.concurrent.duration.FiniteDuration = 123456 nanoseconds

Upvotes: 60

Tyth
Tyth

Reputation: 1814

I don't know any better way, but you can make it a bit shorter:

Duration.fromNanos(d.toNanos)

and also wrap it into an implicit conversion yourself

implicit def toFiniteDuration(d: java.time.Duration): FiniteDuration = Duration.fromNanos(d.toNanos)

(changed d.toNano to d.toNanos)

Upvotes: 23

Related Questions