package kotlin.time

import kotlin.contracts.*

import kotlin.jvm.JvmInline

import kotlin.math.*

@SinceKotlin("1.6")

@WasExperimental(ExperimentalTime::class)

@JvmInline

public value class Duration internal constructor(private val rawValue: Long) : Comparable<Duration> {

private val value: Long get() = rawValue shr 1

private inline val unitDiscriminator: Int get() = rawValue.toInt() and 1

private fun isInNanos() = unitDiscriminator == 0

private fun isInMillis() = unitDiscriminator == 1

private val storageUnit get() = if (isInNanos()) DurationUnit.NANOSECONDS else DurationUnit.MILLISECONDS

init {

if (durationAssertionsEnabled) {

if (isInNanos()) {

if (value !in -MAX_NANOS..MAX_NANOS) throw AssertionError("$value ns is out of nanoseconds range")

} else {

if (value !in -MAX_MILLIS..MAX_MILLIS) throw AssertionError("$value ms is out of milliseconds range")

if (value in -MAX_NANOS_IN_MILLIS..MAX_NANOS_IN_MILLIS) throw AssertionError("$value ms is denormalized")

}

}

}

companion object {

/** The duration equal to exactly 0 seconds. */

public val ZERO: Duration = Duration(0L)

/** The duration whose value is positive infinity. It is useful for representing timeouts that should never expire. */

public val INFINITE: Duration = durationOfMillis(MAX_MILLIS)

internal val NEG_INFINITE: Duration = durationOfMillis(-MAX_MILLIS)

/** Converts the given time duration [value] expressed in the specified [sourceUnit] into the specified [targetUnit]. */

@ExperimentalTime

public fun convert(value: Double, sourceUnit: DurationUnit, targetUnit: DurationUnit): Double =

convertDurationUnit(value, sourceUnit, targetUnit)

// Duration construction extension properties in Duration companion scope

/** Returns a [Duration] equal to this [Int] number of nanoseconds. */

@kotlin.internal.InlineOnly

public inline val Int.nanoseconds get() = toDuration(DurationUnit.NANOSECONDS)

/** Returns a [Duration] equal to this [Long] number of nanoseconds. */

@kotlin.internal.InlineOnly

public inline val Long.nanoseconds get() = toDuration(DurationUnit.NANOSECONDS)

/**

@kotlin.internal.InlineOnly

public inline val Double.nanoseconds get() = toDuration(DurationUnit.NANOSECONDS)

/** Returns a [Duration] equal to this [Int] number of microseconds. */

@kotlin.internal.InlineOnly

public inline val Int.microseconds get() = toDuration(DurationUnit.MICROSECONDS)

/** Returns a [Duration] equal to this [Long] number of microseconds. */

@kotlin.internal.InlineOnly

public inline val Long.microseconds get() = toDuration(DurationUnit.MICROSECONDS)

/**

@kotlin.internal.InlineOnly

public inline val Double.microseconds get() = toDuration(DurationUnit.MICROSECONDS)

/** Returns a [Duration] equal to this [Int] number of milliseconds. */

@kotlin.internal.InlineOnly

public inline val Int.milliseconds get() = toDuration(DurationUnit.MILLISECONDS)

/** Returns a [Duration] equal to this [Long] number of milliseconds. */

@kotlin.internal.InlineOnly

public inline val Long.milliseconds get() = toDuration(DurationUnit.MILLISECONDS)

/**

@kotlin.internal.InlineOnly

public inline val Double.milliseconds get() = toDuration(DurationUnit.MILLISECONDS)

/** Returns a [Duration] equal to this [Int] number of seconds. */

@kotlin.internal.InlineOnly

public inline val Int.seconds get() = toDuration(DurationUnit.SECONDS)

/** Returns a [Duration] equal to this [Long] number of seconds. */

@kotlin.internal.InlineOnly

public inline val Long.seconds get() = toDuration(DurationUnit.SECONDS)

/**

@kotlin.internal.InlineOnly

public inline val Double.seconds get() = toDuration(DurationUnit.SECONDS)

/** Returns a [Duration] equal to this [Int] number of minutes. */

@kotlin.internal.InlineOnly

public inline val Int.minutes get() = toDuration(DurationUnit.MINUTES)

/** Returns a [Duration] equal to this [Long] number of minutes. */

@kotlin.internal.InlineOnly

public inline val Long.minutes get() = toDuration(DurationUnit.MINUTES)

/**

@kotlin.internal.InlineOnly

public inline val Double.minutes get() = toDuration(DurationUnit.MINUTES)

/** Returns a [Duration] equal to this [Int] number of hours. */

@kotlin.internal.InlineOnly

public inline val Int.hours get() = toDuration(DurationUnit.HOURS)

/** Returns a [Duration] equal to this [Long] number of hours. */

@kotlin.internal.InlineOnly

public inline val Long.hours get() = toDuration(DurationUnit.HOURS)

/**

@kotlin.internal.InlineOnly

public inline val Double.hours get() = toDuration(DurationUnit.HOURS)

/** Returns a [Duration] equal to this [Int] number of days. */

@kotlin.internal.InlineOnly

public inline val Int.days get() = toDuration(DurationUnit.DAYS)

/** Returns a [Duration] equal to this [Long] number of days. */

@kotlin.internal.InlineOnly

public inline val Long.days get() = toDuration(DurationUnit.DAYS)

/**

@kotlin.internal.InlineOnly

public inline val Double.days get() = toDuration(DurationUnit.DAYS)

// deprecated static factory functions

/** Returns a [Duration] representing the specified [value] number of nanoseconds. */

@SinceKotlin("1.5")

@ExperimentalTime

@Deprecated("Use 'Int.nanoseconds' extension property from Duration.Companion instead.", ReplaceWith("value.nanoseconds", "kotlin.time.Duration.Companion.nanoseconds"))

@DeprecatedSinceKotlin(warningSince = "1.6", errorSince = "1.8")

public fun nanoseconds(value: Int): Duration = value.toDuration(DurationUnit.NANOSECONDS)

/** Returns a [Duration] representing the specified [value] number of nanoseconds. */

@SinceKotlin("1.5")

@ExperimentalTime

@Deprecated("Use 'Long.nanoseconds' extension property from Duration.Companion instead.", ReplaceWith("value.nanoseconds", "kotlin.time.Duration.Companion.nanoseconds"))

@DeprecatedSinceKotlin(warningSince = "1.6", errorSince = "1.8")

public fun nanoseconds(value: Long): Duration = value.toDuration(DurationUnit.NANOSECONDS)

/**

@SinceKotlin("1.5")

@ExperimentalTime

@Deprecated("Use 'Double.nanoseconds' extension property from Duration.Companion instead.", ReplaceWith("value.nanoseconds", "kotlin.time.Duration.Companion.nanoseconds"))

@DeprecatedSinceKotlin(warningSince = "1.6", errorSince = "1.8")

public fun nanoseconds(value: Double): Duration = value.toDuration(DurationUnit.NANOSECONDS)

/** Returns a [Duration] representing the specified [value] number of microseconds. */

@SinceKotlin("1.5")

@ExperimentalTime

@Deprecated("Use 'Int.microseconds' extension property from Duration.Companion instead.", ReplaceWith("value.microseconds", "kotlin.time.Duration.Companion.microseconds"))

@DeprecatedSinceKotlin(warningSince = "1.6", errorSince = "1.8")

public fun microseconds(value: Int): Duration = value.toDuration(DurationUnit.MICROSECONDS)

/** Returns a [Duration] representing the specified [value] number of microseconds. */

@SinceKotlin("1.5")

@ExperimentalTime

@Deprecated("Use 'Long.microseconds' extension property from Duration.Companion instead.", ReplaceWith("value.microseconds", "kotlin.time.Duration.Companion.microseconds"))

@DeprecatedSinceKotlin(warningSince = "1.6", errorSince = "1.8")

public fun microseconds(value: Long): Duration = value.toDuration(DurationUnit.MICROSECONDS)

/**

@SinceKotlin("1.5")

@ExperimentalTime

@Deprecated("Use 'Double.microseconds' extension property from Duration.Companion instead.", ReplaceWith("value.microseconds", "kotlin.time.Duration.Companion.microseconds"))

@DeprecatedSinceKotlin(warningSince = "1.6", errorSince = "1.8")

public fun microseconds(value: Double): Duration = value.toDuration(DurationUnit.MICROSECONDS)

/** Returns a [Duration] representing the specified [value] number of milliseconds. */

@SinceKotlin("1.5")

@ExperimentalTime

@Deprecated("Use 'Int.milliseconds' extension property from Duration.Companion instead.", ReplaceWith("value.milliseconds", "kotlin.time.Duration.Companion.milliseconds"))

@DeprecatedSinceKotlin(warningSince = "1.6", errorSince = "1.8")

public fun milliseconds(value: Int): Duration = value.toDuration(DurationUnit.MILLISECONDS)

/** Returns a [Duration] representing the specified [value] number of milliseconds. */

@SinceKotlin("1.5")

@ExperimentalTime

@Deprecated("Use 'Long.milliseconds' extension property from Duration.Companion instead.", ReplaceWith("value.milliseconds", "kotlin.time.Duration.Companion.milliseconds"))

@DeprecatedSinceKotlin(warningSince = "1.6", errorSince = "1.8")

public fun milliseconds(value: Long): Duration = value.toDuration(DurationUnit.MILLISECONDS)

/**

@SinceKotlin("1.5")

@ExperimentalTime

@Deprecated("Use 'Double.milliseconds' extension property from Duration.Companion instead.", ReplaceWith("value.milliseconds", "kotlin.time.Duration.Companion.milliseconds"))

@DeprecatedSinceKotlin(warningSince = "1.6", errorSince = "1.8")

public fun milliseconds(value: Double): Duration = value.toDuration(DurationUnit.MILLISECONDS)

/** Returns a [Duration] representing the specified [value] number of seconds. */

@SinceKotlin("1.5")

@ExperimentalTime

@Deprecated("Use 'Int.seconds' extension property from Duration.Companion instead.", ReplaceWith("value.seconds", "kotlin.time.Duration.Companion.seconds"))

@DeprecatedSinceKotlin(warningSince = "1.6", errorSince = "1.8")

public fun seconds(value: Int): Duration = value.toDuration(DurationUnit.SECONDS)

/** Returns a [Duration] representing the specified [value] number of seconds. */

@SinceKotlin("1.5")

@ExperimentalTime

@Deprecated("Use 'Long.seconds' extension property from Duration.Companion instead.", ReplaceWith("value.seconds", "kotlin.time.Duration.Companion.seconds"))

@DeprecatedSinceKotlin(warningSince = "1.6", errorSince = "1.8")

public fun seconds(value: Long): Duration = value.toDuration(DurationUnit.SECONDS)

/**

@SinceKotlin("1.5")

@ExperimentalTime

@Deprecated("Use 'Double.seconds' extension property from Duration.Companion instead.", ReplaceWith("value.seconds", "kotlin.time.Duration.Companion.seconds"))

@DeprecatedSinceKotlin(warningSince = "1.6", errorSince = "1.8")

public fun seconds(value: Double): Duration = value.toDuration(DurationUnit.SECONDS)

/** Returns a [Duration] representing the specified [value] number of minutes. */

@SinceKotlin("1.5")

@ExperimentalTime

@Deprecated("Use 'Int.minutes' extension property from Duration.Companion instead.", ReplaceWith("value.minutes", "kotlin.time.Duration.Companion.minutes"))

@DeprecatedSinceKotlin(warningSince = "1.6", errorSince = "1.8")

public fun minutes(value: Int): Duration = value.toDuration(DurationUnit.MINUTES)

/** Returns a [Duration] representing the specified [value] number of minutes. */

@SinceKotlin("1.5")

@ExperimentalTime

@Deprecated("Use 'Long.minutes' extension property from Duration.Companion instead.", ReplaceWith("value.minutes", "kotlin.time.Duration.Companion.minutes"))

@DeprecatedSinceKotlin(warningSince = "1.6", errorSince = "1.8")

public fun minutes(value: Long): Duration = value.toDuration(DurationUnit.MINUTES)

/**

@SinceKotlin("1.5")

@ExperimentalTime

@Deprecated("Use 'Double.minutes' extension property from Duration.Companion instead.", ReplaceWith("value.minutes", "kotlin.time.Duration.Companion.minutes"))

@DeprecatedSinceKotlin(warningSince = "1.6", errorSince = "1.8")

public fun minutes(value: Double): Duration = value.toDuration(DurationUnit.MINUTES)

/** Returns a [Duration] representing the specified [value] number of hours. */

@SinceKotlin("1.5")

@ExperimentalTime

@Deprecated("Use 'Int.hours' extension property from Duration.Companion instead.", ReplaceWith("value.hours", "kotlin.time.Duration.Companion.hours"))

@DeprecatedSinceKotlin(warningSince = "1.6", errorSince = "1.8")

public fun hours(value: Int): Duration = value.toDuration(DurationUnit.HOURS)

/** Returns a [Duration] representing the specified [value] number of hours. */

@SinceKotlin("1.5")

@ExperimentalTime

@Deprecated("Use 'Long.hours' extension property from Duration.Companion instead.", ReplaceWith("value.hours", "kotlin.time.Duration.Companion.hours"))

@DeprecatedSinceKotlin(warningSince = "1.6", errorSince = "1.8")

public fun hours(value: Long): Duration = value.toDuration(DurationUnit.HOURS)

/**

@SinceKotlin("1.5")

@ExperimentalTime

@Deprecated("Use 'Double.hours' extension property from Duration.Companion instead.", ReplaceWith("value.hours", "kotlin.time.Duration.Companion.hours"))

@DeprecatedSinceKotlin(warningSince = "1.6", errorSince = "1.8")

public fun hours(value: Double): Duration = value.toDuration(DurationUnit.HOURS)

/** Returns a [Duration] representing the specified [value] number of days. */

@SinceKotlin("1.5")

@ExperimentalTime

@Deprecated("Use 'Int.days' extension property from Duration.Companion instead.", ReplaceWith("value.days", "kotlin.time.Duration.Companion.days"))

@DeprecatedSinceKotlin(warningSince = "1.6", errorSince = "1.8")

public fun days(value: Int): Duration = value.toDuration(DurationUnit.DAYS)

/** Returns a [Duration] representing the specified [value] number of days. */

@SinceKotlin("1.5")

@ExperimentalTime

@Deprecated("Use 'Long.days' extension property from Duration.Companion instead.", ReplaceWith("value.days", "kotlin.time.Duration.Companion.days"))

@DeprecatedSinceKotlin(warningSince = "1.6", errorSince = "1.8")

public fun days(value: Long): Duration = value.toDuration(DurationUnit.DAYS)

/**

@SinceKotlin("1.5")

@ExperimentalTime

@Deprecated("Use 'Double.days' extension property from Duration.Companion instead.", ReplaceWith("value.days", "kotlin.time.Duration.Companion.days"))

@DeprecatedSinceKotlin(warningSince = "1.6", errorSince = "1.8")

public fun days(value: Double): Duration = value.toDuration(DurationUnit.DAYS)

/**

public fun parse(value: String): Duration = try {

parseDuration(value, strictIso = false)

} catch (e: IllegalArgumentException) {

throw IllegalArgumentException("Invalid duration string format: '$value'.", e)

}

/**

public fun parseIsoString(value: String): Duration = try {

parseDuration(value, strictIso = true)

} catch (e: IllegalArgumentException) {

throw IllegalArgumentException("Invalid ISO duration string format: '$value'.", e)

}

/**

public fun parseOrNull(value: String): Duration? = try {

parseDuration(value, strictIso = false)

} catch (e: IllegalArgumentException) {

null

}

/**

public fun parseIsoStringOrNull(value: String): Duration? = try {

parseDuration(value, strictIso = true)

} catch (e: IllegalArgumentException) {

null

}

}

// arithmetic operators

/** Returns the negative of this value. */

public operator fun unaryMinus(): Duration = durationOf(-value, unitDiscriminator)

/**

public operator fun plus(other: Duration): Duration {

when {

this.isInfinite() -> {

if (other.isFinite() || (this.rawValue xor other.rawValue >= 0))

return this

else

throw IllegalArgumentException("Summing infinite durations of different signs yields an undefined result.")

}

other.isInfinite() -> return other

}

return when {

this.unitDiscriminator == other.unitDiscriminator -> {

val result = this.value + other.value // never overflows long, but can overflow long63

when {

isInNanos() ->

durationOfNanosNormalized(result)

else ->

durationOfMillisNormalized(result)

}

}

this.isInMillis() ->

addValuesMixedRanges(this.value, other.value)

else ->

addValuesMixedRanges(other.value, this.value)

}

}

private fun addValuesMixedRanges(thisMillis: Long, otherNanos: Long): Duration {

val otherMillis = nanosToMillis(otherNanos)

val resultMillis = thisMillis + otherMillis

return if (resultMillis in -MAX_NANOS_IN_MILLIS..MAX_NANOS_IN_MILLIS) {

val otherNanoRemainder = otherNanos - millisToNanos(otherMillis)

durationOfNanos(millisToNanos(resultMillis) + otherNanoRemainder)

} else {

durationOfMillis(resultMillis.coerceIn(-MAX_MILLIS, MAX_MILLIS))

}

}

/**

public operator fun minus(other: Duration): Duration = this + (-other)

/**

public operator fun times(scale: Int): Duration {

if (isInfinite()) {

return when {

scale == 0 -> throw IllegalArgumentException("Multiplying infinite duration by zero yields an undefined result.")

scale > 0 -> this

else -> -this

}

}

if (scale == 0) return ZERO

val value = value

val result = value * scale

return if (isInNanos()) {

if (value in (MAX_NANOS / Int.MIN_VALUE)..(-MAX_NANOS / Int.MIN_VALUE)) {

// can't overflow nanos range for any scale

durationOfNanos(result)

} else {

if (result / scale == value) {

durationOfNanosNormalized(result)

} else {

val millis = nanosToMillis(value)

val remNanos = value - millisToNanos(millis)

val resultMillis = millis * scale

val totalMillis = resultMillis + nanosToMillis(remNanos * scale)

if (resultMillis / scale == millis && totalMillis xor resultMillis >= 0) {

durationOfMillis(totalMillis.coerceIn(-MAX_MILLIS..MAX_MILLIS))

} else {

if (value.sign * scale.sign > 0) INFINITE else NEG_INFINITE

}

}

}

} else {

if (result / scale == value) {

durationOfMillis(result.coerceIn(-MAX_MILLIS..MAX_MILLIS))

} else {

if (value.sign * scale.sign > 0) INFINITE else NEG_INFINITE

}

}

}

/**

public operator fun times(scale: Double): Duration {

val intScale = scale.roundToInt()

if (intScale.toDouble() == scale) {

return times(intScale)

}

val unit = storageUnit

val result = toDouble(unit) * scale

return result.toDuration(unit)

}

/**

public operator fun div(scale: Int): Duration {

if (scale == 0) {

return when {

isPositive() -> INFINITE

isNegative() -> NEG_INFINITE

else -> throw IllegalArgumentException("Dividing zero duration by zero yields an undefined result.")

}

}

if (isInNanos()) {

return durationOfNanos(value / scale)

} else {

if (isInfinite())

return this * scale.sign

val result = value / scale

if (result in -MAX_NANOS_IN_MILLIS..MAX_NANOS_IN_MILLIS) {

val rem = millisToNanos(value - (result * scale)) / scale

return durationOfNanos(millisToNanos(result) + rem)

}

return durationOfMillis(result)

}

}

/**

public operator fun div(scale: Double): Duration {

val intScale = scale.roundToInt()

if (intScale.toDouble() == scale && intScale != 0) {

return div(intScale)

}

val unit = storageUnit

val result = toDouble(unit) / scale

return result.toDuration(unit)

}

/** Returns a number that is the ratio of this and [other] duration values. */

public operator fun div(other: Duration): Double {

val coarserUnit = maxOf(this.storageUnit, other.storageUnit)

return this.toDouble(coarserUnit) / other.toDouble(coarserUnit)

}

/** Returns true, if the duration value is less than zero. */

public fun isNegative(): Boolean = rawValue < 0

/** Returns true, if the duration value is greater than zero. */

public fun isPositive(): Boolean = rawValue > 0

/** Returns true, if the duration value is infinite. */

public fun isInfinite(): Boolean = rawValue == INFINITE.rawValue || rawValue == NEG_INFINITE.rawValue

/** Returns true, if the duration value is finite. */

public fun isFinite(): Boolean = !isInfinite()

/** Returns the absolute value of this value. The returned value is always non-negative. */

public val absoluteValue: Duration get() = if (isNegative()) -this else this

override fun compareTo(other: Duration): Int {

val compareBits = this.rawValue xor other.rawValue

if (compareBits < 0 || compareBits.toInt() and 1 == 0) // different signs or same sign/same range

return this.rawValue.compareTo(other.rawValue)

// same sign/different ranges

val r = this.unitDiscriminator - other.unitDiscriminator // compare ranges

return if (isNegative()) -r else r

}

// splitting to components

/**

public inline fun <T> toComponents(action: (days: Long, hours: Int, minutes: Int, seconds: Int, nanoseconds: Int) -> T): T {

contract { callsInPlace(action, InvocationKind.EXACTLY_ONCE) }

return action(inWholeDays, hoursComponent, minutesComponent, secondsComponent, nanosecondsComponent)

}

/**

public inline fun <T> toComponents(action: (hours: Long, minutes: Int, seconds: Int, nanoseconds: Int) -> T): T {

contract { callsInPlace(action, InvocationKind.EXACTLY_ONCE) }

return action(inWholeHours, minutesComponent, secondsComponent, nanosecondsComponent)

}

/**

public inline fun <T> toComponents(action: (minutes: Long, seconds: Int, nanoseconds: Int) -> T): T {

contract { callsInPlace(action, InvocationKind.EXACTLY_ONCE) }

return action(inWholeMinutes, secondsComponent, nanosecondsComponent)

}

/**

public inline fun <T> toComponents(action: (seconds: Long, nanoseconds: Int) -> T): T {

contract { callsInPlace(action, InvocationKind.EXACTLY_ONCE) }

return action(inWholeSeconds, nanosecondsComponent)

}

@PublishedApi

internal val hoursComponent: Int

get() = if (isInfinite()) 0 else (inWholeHours % 24).toInt()

@PublishedApi

internal val minutesComponent: Int

get() = if (isInfinite()) 0 else (inWholeMinutes % 60).toInt()

@PublishedApi

internal val secondsComponent: Int

get() = if (isInfinite()) 0 else (inWholeSeconds % 60).toInt()

@PublishedApi

internal val nanosecondsComponent: Int

get() = when {

isInfinite() -> 0

isInMillis() -> millisToNanos(value % 1_000).toInt()

else -> (value % 1_000_000_000).toInt()

}

// conversion to units

/**

public fun toDouble(unit: DurationUnit): Double {

return when (rawValue) {

INFINITE.rawValue -> Double.POSITIVE_INFINITY

NEG_INFINITE.rawValue -> Double.NEGATIVE_INFINITY

else -> {

// TODO: whether it's ok to convert to Double before scaling

convertDurationUnit(value.toDouble(), storageUnit, unit)

}

}

}

/**

public fun toLong(unit: DurationUnit): Long {

return when (rawValue) {

INFINITE.rawValue -> Long.MAX_VALUE

NEG_INFINITE.rawValue -> Long.MIN_VALUE

else -> convertDurationUnit(value, storageUnit, unit)

}

}

/**

public fun toInt(unit: DurationUnit): Int =

toLong(unit).coerceIn(Int.MIN_VALUE.toLong(), Int.MAX_VALUE.toLong()).toInt()

/** The value of this duration expressed as a [Double] number of days. */

@ExperimentalTime

@Deprecated("Use inWholeDays property instead or convert toDouble(DAYS) if a double value is required.", ReplaceWith("toDouble(DurationUnit.DAYS)"))

@DeprecatedSinceKotlin(warningSince = "1.5", errorSince = "1.8")

public val inDays: Double get() = toDouble(DurationUnit.DAYS)

/** The value of this duration expressed as a [Double] number of hours. */

@ExperimentalTime

@Deprecated("Use inWholeHours property instead or convert toDouble(HOURS) if a double value is required.", ReplaceWith("toDouble(DurationUnit.HOURS)"))

@DeprecatedSinceKotlin(warningSince = "1.5", errorSince = "1.8")

public val inHours: Double get() = toDouble(DurationUnit.HOURS)

/** The value of this duration expressed as a [Double] number of minutes. */

@ExperimentalTime

@Deprecated("Use inWholeMinutes property instead or convert toDouble(MINUTES) if a double value is required.", ReplaceWith("toDouble(DurationUnit.MINUTES)"))

@DeprecatedSinceKotlin(warningSince = "1.5", errorSince = "1.8")

public val inMinutes: Double get() = toDouble(DurationUnit.MINUTES)

/** The value of this duration expressed as a [Double] number of seconds. */

@ExperimentalTime

@Deprecated("Use inWholeSeconds property instead or convert toDouble(SECONDS) if a double value is required.", ReplaceWith("toDouble(DurationUnit.SECONDS)"))

@DeprecatedSinceKotlin(warningSince = "1.5", errorSince = "1.8")

public val inSeconds: Double get() = toDouble(DurationUnit.SECONDS)

/** The value of this duration expressed as a [Double] number of milliseconds. */

@ExperimentalTime

@Deprecated("Use inWholeMilliseconds property instead or convert toDouble(MILLISECONDS) if a double value is required.", ReplaceWith("toDouble(DurationUnit.MILLISECONDS)"))

@DeprecatedSinceKotlin(warningSince = "1.5", errorSince = "1.8")

public val inMilliseconds: Double get() = toDouble(DurationUnit.MILLISECONDS)

/** The value of this duration expressed as a [Double] number of microseconds. */

@ExperimentalTime

@Deprecated("Use inWholeMicroseconds property instead or convert toDouble(MICROSECONDS) if a double value is required.", ReplaceWith("toDouble(DurationUnit.MICROSECONDS)"))

@DeprecatedSinceKotlin(warningSince = "1.5", errorSince = "1.8")

public val inMicroseconds: Double get() = toDouble(DurationUnit.MICROSECONDS)

/** The value of this duration expressed as a [Double] number of nanoseconds. */

@ExperimentalTime

@Deprecated("Use inWholeNanoseconds property instead or convert toDouble(NANOSECONDS) if a double value is required.", ReplaceWith("toDouble(DurationUnit.NANOSECONDS)"))

@DeprecatedSinceKotlin(warningSince = "1.5", errorSince = "1.8")

public val inNanoseconds: Double get() = toDouble(DurationUnit.NANOSECONDS)

/**

public val inWholeDays: Long

get() = toLong(DurationUnit.DAYS)

/**

public val inWholeHours: Long

get() = toLong(DurationUnit.HOURS)

/**

public val inWholeMinutes: Long

get() = toLong(DurationUnit.MINUTES)

/**

public val inWholeSeconds: Long

get() = toLong(DurationUnit.SECONDS)

/**

public val inWholeMilliseconds: Long

get() {

return if (isInMillis() && isFinite()) value else toLong(DurationUnit.MILLISECONDS)

}

/**

public val inWholeMicroseconds: Long

get() = toLong(DurationUnit.MICROSECONDS)

/**

public val inWholeNanoseconds: Long

get() {

val value = value

return when {

isInNanos() -> value

value > Long.MAX_VALUE / NANOS_IN_MILLIS -> Long.MAX_VALUE

value < Long.MIN_VALUE / NANOS_IN_MILLIS -> Long.MIN_VALUE

else -> millisToNanos(value)

}

}

// shortcuts

/**

@ExperimentalTime

@Deprecated("Use inWholeNanoseconds property instead.", ReplaceWith("this.inWholeNanoseconds"))

@DeprecatedSinceKotlin(warningSince = "1.5", errorSince = "1.8")

public fun toLongNanoseconds(): Long = inWholeNanoseconds

/**

@ExperimentalTime

@Deprecated("Use inWholeMilliseconds property instead.", ReplaceWith("this.inWholeMilliseconds"))

@DeprecatedSinceKotlin(warningSince = "1.5", errorSince = "1.8")

public fun toLongMilliseconds(): Long = inWholeMilliseconds

/**

override fun toString(): String = when (rawValue) {

0L -> "0s"

INFINITE.rawValue -> "Infinity"

NEG_INFINITE.rawValue -> "-Infinity"

else -> {

val isNegative = isNegative()

buildString {

if (isNegative) append('-')

absoluteValue.toComponents { days, hours, minutes, seconds, nanoseconds ->

val hasDays = days != 0L

val hasHours = hours != 0

val hasMinutes = minutes != 0

val hasSeconds = seconds != 0 || nanoseconds != 0

var components = 0

if (hasDays) {

append(days).append('d')

components++

}

if (hasHours || (hasDays && (hasMinutes || hasSeconds))) {

if (components++ > 0) append(' ')

append(hours).append('h')

}

if (hasMinutes || (hasSeconds && (hasHours || hasDays))) {

if (components++ > 0) append(' ')

append(minutes).append('m')

}

if (hasSeconds) {

if (components++ > 0) append(' ')

when {

seconds != 0 || hasDays || hasHours || hasMinutes ->

appendFractional(seconds, nanoseconds, 9, "s", isoZeroes = false)

nanoseconds >= 1_000_000 ->

appendFractional(nanoseconds / 1_000_000, nanoseconds % 1_000_000, 6, "ms", isoZeroes = false)

nanoseconds >= 1_000 ->

appendFractional(nanoseconds / 1_000, nanoseconds % 1_000, 3, "us", isoZeroes = false)

else ->

append(nanoseconds).append("ns")

}

}

if (isNegative && components > 1) insert(1, '(').append(')')

}