kotlinx-serialization support

build.gradle.kts

@@ -3,12 +3,13 @@ buildscript {
         mavenCentral()
     }
     dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.4.0")
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.4.30")
     }
 }
 
 plugins {
     id("kotlinx.team.infra") version "0.3.0-dev-64"
+    kotlin("plugin.serialization") version "1.4.30"
 }
 
 infra {

core/build.gradle.kts

@@ -5,6 +5,7 @@ import javax.xml.parsers.DocumentBuilderFactory
 
 plugins {
     id("kotlin-multiplatform")
+    kotlin("plugin.serialization")
     `maven-publish`
 }
 
@@ -18,6 +19,7 @@ base {
 
 //val JDK_6: String by project
 val JDK_8: String by project
+val serializationVersion: String by project
 
 kotlin {
     infra {
@@ -148,6 +150,7 @@ kotlin {
         commonMain {
             dependencies {
                 api("org.jetbrains.kotlin:kotlin-stdlib-common")
+                compileOnly("org.jetbrains.kotlinx:kotlinx-serialization-core:$serializationVersion")
             }
         }
 

core/common/src/DateTimePeriod.kt

@@ -5,10 +5,14 @@
 
 package kotlinx.datetime
 
+import kotlinx.datetime.serializers.DatePeriodISO8601Serializer
+import kotlinx.datetime.serializers.DateTimePeriodISO8601Serializer
 import kotlin.math.*
 import kotlin.time.Duration
 import kotlin.time.ExperimentalTime
+import kotlinx.serialization.Serializable
 
+@Serializable(with = DateTimePeriodISO8601Serializer::class)
 // TODO: could be error-prone without explicitly named params
 sealed class DateTimePeriod {
     internal abstract val totalMonths: Int
@@ -233,9 +237,10 @@ sealed class DateTimePeriod {
 
 public fun String.toDateTimePeriod(): DateTimePeriod = DateTimePeriod.parse(this)
 
+@Serializable(with = DatePeriodISO8601Serializer::class)
 class DatePeriod internal constructor(
-    internal override val totalMonths: Int,
-    override val days: Int,
+        internal override val totalMonths: Int,
+        override val days: Int,
 ) : DateTimePeriod() {
     constructor(years: Int = 0, months: Int = 0, days: Int = 0): this(totalMonths(years, months), days)
     // avoiding excessive computations

core/common/src/DateTimeUnit.kt

@@ -5,14 +5,16 @@
 
 package kotlinx.datetime
 
-import kotlin.time.Duration
-import kotlin.time.ExperimentalTime
-import kotlin.time.nanoseconds
+import kotlinx.datetime.serializers.*
+import kotlinx.serialization.Serializable
+import kotlin.time.*
 
+@Serializable(with = DateTimeUnitSerializer::class)
 sealed class DateTimeUnit {
 
     abstract operator fun times(scalar: Int): DateTimeUnit
 
+    @Serializable(with = TimeBasedDateTimeUnitSerializer::class)
     class TimeBased(val nanoseconds: Long) : DateTimeUnit() {
         private val unitName: String
         private val unitScale: Long
@@ -51,7 +53,8 @@ sealed class DateTimeUnit {
         override fun times(scalar: Int): TimeBased = TimeBased(safeMultiply(nanoseconds, scalar.toLong()))
 
         @ExperimentalTime
-        val duration: Duration = nanoseconds.nanoseconds
+        val duration: Duration
+            get() = nanoseconds.nanoseconds
 
         override fun equals(other: Any?): Boolean =
                 this === other || (other is TimeBased && this.nanoseconds == other.nanoseconds)
@@ -61,8 +64,10 @@ sealed class DateTimeUnit {
         override fun toString(): String = formatToString(unitScale, unitName)
     }
 
+    @Serializable(with = DateBasedDateTimeUnitSerializer::class)
     sealed class DateBased : DateTimeUnit() {
         // TODO: investigate how to move subclasses up to DateTimeUnit scope
+        @Serializable(with = DayBasedDateTimeUnitSerializer::class)
         class DayBased(val days: Int) : DateBased() {
             init {
                 require(days > 0) { "Unit duration must be positive, but was $days days." }
@@ -80,6 +85,7 @@ sealed class DateTimeUnit {
             else
                 formatToString(days, "DAY")
         }
+        @Serializable(with = MonthBasedDateTimeUnitSerializer::class)
         class MonthBased(val months: Int) : DateBased() {
             init {
                 require(months > 0) { "Unit duration must be positive, but was $months months." }

core/common/src/Instant.kt

@@ -5,10 +5,12 @@
 
 package kotlinx.datetime
 
-import kotlin.time.Duration
-import kotlin.time.ExperimentalTime
+import kotlinx.datetime.serializers.InstantISO8601Serializer
+import kotlinx.serialization.Serializable
+import kotlin.time.*
 
 @OptIn(ExperimentalTime::class)
+@Serializable(with = InstantISO8601Serializer::class)
 public expect class Instant : Comparable<Instant> {
 
     /**

core/common/src/LocalDate.kt

@@ -5,6 +5,10 @@
 
 package kotlinx.datetime
 
+import kotlinx.datetime.serializers.LocalDateISO8601Serializer
+import kotlinx.serialization.Serializable
+
+@Serializable(with = LocalDateISO8601Serializer::class)
 public expect class LocalDate : Comparable<LocalDate> {
     companion object {
         /**

core/common/src/LocalDateTime.kt

@@ -5,8 +5,10 @@
 
 package kotlinx.datetime
 
+import kotlinx.datetime.serializers.LocalDateTimeISO8601Serializer
+import kotlinx.serialization.Serializable
 
-
+@Serializable(with = LocalDateTimeISO8601Serializer::class)
 public expect class LocalDateTime : Comparable<LocalDateTime> {
     companion object {
 

core/common/src/Month.kt

@@ -20,7 +20,6 @@ public expect enum class Month {
     OCTOBER,
     NOVEMBER,
     DECEMBER;
-
 //    val value: Int // member missing in java.time.Month has to be an extension
 }
 

core/common/src/TimeZone.kt

@@ -8,6 +8,11 @@
 
 package kotlinx.datetime
 
+import kotlinx.datetime.serializers.TimeZoneSerializer
+import kotlinx.datetime.serializers.ZoneOffsetSerializer
+import kotlinx.serialization.Serializable
+
+@Serializable(with = TimeZoneSerializer::class)
 public expect open class TimeZone {
     /**
      * Returns the identifier string of the time zone.
@@ -80,6 +85,7 @@ public expect open class TimeZone {
     public fun LocalDateTime.toInstant(): Instant
 }
 
+@Serializable(with = ZoneOffsetSerializer::class)
 public expect class ZoneOffset : TimeZone {
     val totalSeconds: Int
 }

core/common/src/math.kt

@@ -133,9 +133,12 @@ internal class DivRemResult(val q: Long, val r: Long) {
     operator fun component2(): Long = r
 }
 
+@Suppress("NOTHING_TO_INLINE")
 private inline fun low(x: Long) = x and 0xffffffff
+@Suppress("NOTHING_TO_INLINE")
 private inline fun high(x: Long) = (x shr 32) and 0xffffffff
 /** For [bit] in [0; 63], return bit #[bit] of [value], counting from the least significant bit */
+@Suppress("NOTHING_TO_INLINE")
 private inline fun indexBit(value: Long, bit: Int): Long = (value shr bit and 1)
 
 

core/common/src/serializers/DateTimePeriodSerializers.kt

@@ -0,0 +1,153 @@
+/*
+ * Copyright 2019-2021 JetBrains s.r.o.
+ * Use of this source code is governed by the Apache 2.0 License that can be found in the LICENSE.txt file.
+ */
+
+package kotlinx.datetime.serializers
+
+import kotlinx.datetime.DatePeriod
+import kotlinx.datetime.DateTimePeriod
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.SerializationException
+import kotlinx.serialization.descriptors.*
+import kotlinx.serialization.encoding.*
+
+object DateTimePeriodComponentSerializer: KSerializer<DateTimePeriod> {
+
+    override val descriptor: SerialDescriptor =
+        buildClassSerialDescriptor("DateTimePeriod") {
+            element<Int>("years", isOptional = true)
+            element<Int>("months", isOptional = true)
+            element<Int>("days", isOptional = true)
+            element<Int>("hours", isOptional = true)
+            element<Int>("minutes", isOptional = true)
+            element<Int>("seconds", isOptional = true)
+            element<Long>("nanoseconds", isOptional = true)
+        }
+
+    override fun deserialize(decoder: Decoder): DateTimePeriod =
+        decoder.decodeStructure(descriptor) {
+            var years = 0
+            var months = 0
+            var days = 0
+            var hours = 0
+            var minutes = 0
+            var seconds = 0
+            var nanoseconds = 0L
+            loop@while (true) {
+                when (val index = decodeElementIndex(descriptor)) {
+                    0 -> years = decodeIntElement(descriptor, 0)
+                    1 -> months = decodeIntElement(descriptor, 1)
+                    2 -> days = decodeIntElement(descriptor, 2)
+                    3 -> hours = decodeIntElement(descriptor, 3)
+                    4 -> minutes = decodeIntElement(descriptor, 4)
+                    5 -> seconds = decodeIntElement(descriptor, 5)
+                    6 -> nanoseconds = decodeLongElement(descriptor, 6)
+                    CompositeDecoder.DECODE_DONE -> break@loop // https://youtrack.jetbrains.com/issue/KT-42262
+                    else -> throw SerializationException("Unexpected index: $index")
+                }
+            }
+            DateTimePeriod(years, months, days, hours, minutes, seconds, nanoseconds)
+        }
+
+    override fun serialize(encoder: Encoder, value: DateTimePeriod) {
+        encoder.encodeStructure(descriptor) {
+            with(value) {
+                if (years != 0) encodeIntElement(descriptor, 0, years)
+                if (months != 0) encodeIntElement(descriptor, 1, months)
+                if (days != 0) encodeIntElement(descriptor, 2, days)
+                if (hours != 0) encodeIntElement(descriptor, 3, hours)
+                if (minutes != 0) encodeIntElement(descriptor, 4, minutes)
+                if (seconds != 0) encodeIntElement(descriptor, 5, seconds)
+                if (nanoseconds != 0) encodeLongElement(descriptor, 6, value.nanoseconds.toLong())
+            }
+        }
+    }
+
+}
+
+object DateTimePeriodISO8601Serializer: KSerializer<DateTimePeriod> {
+
+    override val descriptor: SerialDescriptor =
+        PrimitiveSerialDescriptor("DateTimePeriod", PrimitiveKind.STRING)
+
+    override fun deserialize(decoder: Decoder): DateTimePeriod =
+        DateTimePeriod.parse(decoder.decodeString())
+
+    override fun serialize(encoder: Encoder, value: DateTimePeriod) {
+        encoder.encodeString(value.toString())
+    }
+
+}
+
+object DatePeriodComponentSerializer: KSerializer<DatePeriod> {
+
+    private fun unexpectedNonzero(fieldName: String, value: Long) {
+        if (value != 0L) {
+            throw SerializationException("DatePeriod should have non-date components be zero, but got $value in '$fieldName'")
+        }
+    }
+
+    private fun unexpectedNonzero(fieldName: String, value: Int) = unexpectedNonzero(fieldName, value.toLong())
+
+    override val descriptor: SerialDescriptor =
+        buildClassSerialDescriptor("DatePeriod") {
+            element<Int>("years", isOptional = true)
+            element<Int>("months", isOptional = true)
+            element<Int>("days", isOptional = true)
+            element<Int>("hours", isOptional = true)
+            element<Int>("minutes", isOptional = true)
+            element<Int>("seconds", isOptional = true)
+            element<Long>("nanoseconds", isOptional = true)
+        }
+
+    override fun deserialize(decoder: Decoder): DatePeriod =
+        decoder.decodeStructure(descriptor) {
+            var years = 0
+            var months = 0
+            var days = 0
+            loop@while (true) {
+                when (val index = decodeElementIndex(descriptor)) {
+                    0 -> years = decodeIntElement(descriptor, 0)
+                    1 -> months = decodeIntElement(descriptor, 1)
+                    2 -> days = decodeIntElement(descriptor, 2)
+                    3 -> unexpectedNonzero("hours", decodeIntElement(descriptor, 3))
+                    4 -> unexpectedNonzero("minutes", decodeIntElement(descriptor, 4))
+                    5 -> unexpectedNonzero("seconds", decodeIntElement(descriptor, 5))
+                    6 -> unexpectedNonzero("nanoseconds", decodeLongElement(descriptor, 6))
+                    CompositeDecoder.DECODE_DONE -> break@loop // https://youtrack.jetbrains.com/issue/KT-42262
+                    else -> throw SerializationException("Unexpected index: $index")
+                }
+            }
+            DatePeriod(years, months, days)
+        }
+
+    override fun serialize(encoder: Encoder, value: DatePeriod) {
+        encoder.encodeStructure(descriptor) {
+            with(value) {
+                if (years != 0) encodeIntElement(DateTimePeriodComponentSerializer.descriptor, 0, years)
+                if (months != 0) encodeIntElement(DateTimePeriodComponentSerializer.descriptor, 1, months)
+                if (days != 0) encodeIntElement(DateTimePeriodComponentSerializer.descriptor, 2, days)
+            }
+        }
+    }
+
+}
+
+object DatePeriodISO8601Serializer: KSerializer<DatePeriod> {
+
+    override val descriptor: SerialDescriptor =
+        PrimitiveSerialDescriptor("DatePeriod", PrimitiveKind.STRING)
+
+    // TODO: consider whether should fail when parsing "P1YT0H0M0.0S"
+    override fun deserialize(decoder: Decoder): DatePeriod =
+        when (val period = DateTimePeriod.parse(decoder.decodeString())) {
+            is DatePeriod -> period
+            else -> throw SerializationException("$period is not a date-based period")
+        }
+
+    override fun serialize(encoder: Encoder, value: DatePeriod) {
+        encoder.encodeString(value.toString())
+    }
+
+}