Common: add Instant.fromEpochSeconds(Long, Int)

This overload allows to pass an Int as the number of nanoseconds.

Author: dkhalanskyjb

core/commonMain/src/Instant.kt

@@ -111,6 +111,14 @@ public expect class Instant : Comparable<Instant> {
          */
         fun fromEpochSeconds(epochSeconds: Long, nanosecondAdjustment: Long = 0): Instant
 
+        /**
+         * Returns an [Instant] that is the [epochSeconds] number of seconds from the epoch instant `1970-01-01T00:00:00Z`
+         * and the [nanosecondAdjustment] number of nanoseconds from the whole second.
+         *
+         * The return value is clamped to the platform-specific boundaries for [Instant] if the result exceeds them.
+         */
+        fun fromEpochSeconds(epochSeconds: Long, nanosecondAdjustment: Int): Instant
+
         /**
          * Parses a string that represents an instant in ISO-8601 format including date and time components and
          * the mandatory `Z` designator of the UTC+0 time zone and returns the parsed [Instant] value.

core/commonTest/src/InstantTest.kt

@@ -264,22 +264,34 @@ class InstantTest {
     @Test
     fun nanosecondAdjustment() {
         for (i in -2..2L) {
-            for (j in 0..9L) {
+            for (j in 0..9) {
                 val t: Instant = Instant.fromEpochSeconds(i, j)
+                val t2: Instant = Instant.fromEpochSeconds(i, j.toLong())
                 assertEquals(i, t.epochSeconds)
-                assertEquals(j, t.nanosecondsOfSecond.toLong())
+                assertEquals(j, t.nanosecondsOfSecond)
+                assertEquals(t, t2)
             }
-            for (j in -10..-1L) {
+            for (j in -10..-1) {
                 val t: Instant = Instant.fromEpochSeconds(i, j)
+                val t2: Instant = Instant.fromEpochSeconds(i, j.toLong())
                 assertEquals(i - 1, t.epochSeconds)
-                assertEquals(j + 1000000000, t.nanosecondsOfSecond.toLong())
+                assertEquals(j + 1000000000, t.nanosecondsOfSecond)
+                assertEquals(t, t2)
             }
-            for (j in 999_999_990..999_999_999L) {
+            for (j in 999_999_990..999_999_999) {
                 val t: Instant = Instant.fromEpochSeconds(i, j)
+                val t2: Instant = Instant.fromEpochSeconds(i, j.toLong())
                 assertEquals(i, t.epochSeconds)
-                assertEquals(j, t.nanosecondsOfSecond.toLong())
+                assertEquals(j, t.nanosecondsOfSecond)
+                assertEquals(t, t2)
             }
         }
+        val t = Instant.fromEpochSeconds(0, Int.MAX_VALUE)
+        assertEquals((Int.MAX_VALUE / 1_000_000_000).toLong(), t.epochSeconds)
+        assertEquals(Int.MAX_VALUE % 1_000_000_000, t.nanosecondsOfSecond)
+        val t2 = Instant.fromEpochSeconds(0, Long.MAX_VALUE)
+        assertEquals(Long.MAX_VALUE / 1_000_000_000, t2.epochSeconds)
+        assertEquals((Long.MAX_VALUE % 1_000_000_000).toInt(), t2.nanosecondsOfSecond)
     }
 
     /* Based on the ThreeTenBp project.

core/jsMain/src/Instant.kt

@@ -86,6 +86,13 @@ public actual class Instant internal constructor(internal val value: jtInstant)
             if (epochSeconds > 0) MAX else MIN
         }
 
+        actual fun fromEpochSeconds(epochSeconds: Long, nanosecondAdjustment: Int): Instant = try {
+            Instant(jtInstant.ofEpochSecond(epochSeconds, nanosecondAdjustment))
+        } catch (e: Throwable) {
+            if (!e.isJodaDateTimeException()) throw e
+            if (epochSeconds > 0) MAX else MIN
+        }
+
         actual val DISTANT_PAST: Instant = Instant(jtInstant.ofEpochSecond(DISTANT_PAST_SECONDS, 999_999_999))
         actual val DISTANT_FUTURE: Instant = Instant(jtInstant.ofEpochSecond(DISTANT_FUTURE_SECONDS, 0))
 

core/jvmMain/src/Instant.kt

@@ -72,6 +72,9 @@ public actual class Instant internal constructor(internal val value: jtInstant)
             if (epochSeconds > 0) MAX else MIN
         }
 
+        actual fun fromEpochSeconds(epochSeconds: Long, nanosecondAdjustment: Int): Instant =
+            fromEpochSeconds(epochSeconds, nanosecondAdjustment.toLong())
+
         actual val DISTANT_PAST: Instant = Instant(jtInstant.ofEpochSecond(DISTANT_PAST_SECONDS, 999_999_999))
         actual val DISTANT_FUTURE: Instant = Instant(jtInstant.ofEpochSecond(DISTANT_FUTURE_SECONDS, 0))
 

core/nativeMain/src/Instant.kt

@@ -250,6 +250,9 @@ public actual class Instant internal constructor(actual val epochSeconds: Long,
                 if (epochSeconds > 0) MAX else MIN
             }
 
+        actual fun fromEpochSeconds(epochSeconds: Long, nanosecondAdjustment: Int): Instant =
+            fromEpochSeconds(epochSeconds, nanosecondAdjustment.toLong())
+
         actual fun parse(isoString: String): Instant =
             instantParser.parse(isoString)