Merge pull request #74 from AVSystem/io-refactor

Input/Output refactor, breaking changes

Author: ghik

commons-benchmark/js/src/main/scala/com/avsystem/commons/Main.scala

@@ -1,12 +1,15 @@
 package com.avsystem.commons
 
-import com.avsystem.commons.ser.Benchmarks
+import com.avsystem.commons.ser.{IsoInstantBenchmarks, JsonBenchmarks}
 import japgolly.scalajs.benchmark.gui.BenchmarkGUI
 import org.scalajs.dom._
 
 object Main {
   def main(args: Array[String]): Unit = {
     val body = document.getElementById("body")
-    BenchmarkGUI.renderSuite(body)(Benchmarks.suite)
+    BenchmarkGUI.renderMenu(body)(
+      IsoInstantBenchmarks.suite,
+      JsonBenchmarks.suite
+    )
   }
 }

commons-benchmark/js/src/main/scala/com/avsystem/commons/ser/IsoInstantBenchmarks.scala

@@ -0,0 +1,34 @@
+package com.avsystem.commons
+package ser
+
+import com.avsystem.commons.serialization.GenCodec.ReadFailure
+import japgolly.scalajs.benchmark.gui.GuiSuite
+import japgolly.scalajs.benchmark.{Benchmark, Suite}
+
+import scala.scalajs.js
+import scala.scalajs.js.RegExp
+
+object IsoInstantBenchmarks {
+  private val regex: RegExp =
+    js.RegExp("""^(\+|-)?[0-9]+-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(\.[0-9]{3})?Z$""")
+
+  def parse(string: String, validate: Boolean): Long = {
+    def fail = throw new ReadFailure(s"invalid ISO instant: $string")
+    if (!validate || regex.test(string)) {
+      val parsed = js.Date.parse(string)
+      if (parsed.isNaN) fail
+      else parsed.toLong
+    } else fail
+  }
+
+  val suite = GuiSuite(
+    Suite("IsoInstant parsing")(
+      Benchmark("with regex validation") {
+        parse("2013-11-27T12:55:32.234Z", validate = true)
+      },
+      Benchmark("without regex validation") {
+        parse("2013-11-27T12:55:32.234Z", validate = false)
+      }
+    )
+  )
+}

commons-benchmark/js/src/main/scala/com/avsystem/commons/ser/Benchmarks.scala renamed to commons-benchmark/js/src/main/scala/com/avsystem/commons/ser/JsonBenchmarks.scala

@@ -7,7 +7,7 @@ import io.circe.syntax._
 import japgolly.scalajs.benchmark.gui.GuiSuite
 import japgolly.scalajs.benchmark.{Benchmark, Suite}
 
-object Benchmarks {
+object JsonBenchmarks {
   val suite = GuiSuite(
     Suite("JSON serialization benchmarks")(
       Benchmark("Writing case class: GenCodec") {

commons-benchmark/jvm/src/main/scala/com/avsystem/commons/ser/GenCodecBenchmarks.scala

@@ -1,45 +1,54 @@
 package com.avsystem.commons
 package ser
 
-import com.avsystem.commons.serialization.GenCodec.ReadFailure
 import com.avsystem.commons.serialization._
+import com.avsystem.commons.serialization.json.{JsonBinaryFormat, JsonOptions, JsonStringInput, JsonStringOutput}
 import org.openjdk.jmh.annotations._
 
-@Warmup(iterations = 5)
-@Measurement(iterations = 20)
+@Warmup(iterations = 5, time = 1)
+@Measurement(iterations = 10, time = 2)
 @Fork(1)
 @BenchmarkMode(Array(Mode.Throughput))
 class GenCodecBenchmarks {
   @Benchmark
-  def testCaseClassCodec(): Simple = GenCodec.read[Simple](DummyInput)
-}
+  def someWriting: String = JsonStringOutput.write(GenCodecBenchmarks.somes)
+
+  @Benchmark
+  def noneWriting: String = JsonStringOutput.write(GenCodecBenchmarks.nones)
 
-case class Simple(int: Int, str: String)
-object Simple {
-  implicit val codec: GenCodec[Simple] = GenCodec.materialize
+  @Benchmark
+  def cleanSomeWriting: String = {
+    implicit val cleanCodec: GenCodec[Option[String]] = GenCodecBenchmarks.cleanOptionCodec[String]
+    JsonStringOutput.write(GenCodecBenchmarks.somes)
+  }
+
+  @Benchmark
+  def cleanNoneWriting: String = {
+    implicit val cleanCodec: GenCodec[Option[String]] = GenCodecBenchmarks.cleanOptionCodec[String]
+    JsonStringOutput.write(GenCodecBenchmarks.nones)
+  }
+
+  @Benchmark
+  def binaryReading: Array[Byte] =
+    JsonStringInput.read[Array[Byte]](GenCodecBenchmarks.hex, GenCodecBenchmarks.options)
 }
 
-object DummyInput extends Input {
-  private def ignored = throw new ReadFailure("don't care")
-
-  def inputType = InputType.Object
-  def readBinary() = ignored
-  def readLong() = ignored
-  def readNull() = ignored
-  def readObject() = new ObjectInput {
-    private val it = Iterator(
-      new SimpleValueFieldInput("int", 42),
-      new SimpleValueFieldInput("str", "lol")
+object GenCodecBenchmarks {
+  implicit def cleanOptionCodec[T: GenCodec]: GenCodec[Option[T]] =
+    GenCodec.create[Option[T]](
+      i => if (i.isNull) {
+        i.readNull()
+        None
+      } else Some(GenCodec.read[T](i)),
+      (o, vo) => vo match {
+        case Some(v) => GenCodec.write[T](o, v)
+        case None => o.writeNull()
+      }
     )
-    def nextField() = it.next()
-    def hasNext = it.hasNext
-  }
-  def readInt() = ignored
-  def readString() = ignored
-  def readList() = ignored
-  def readBoolean() = ignored
-  def readDouble() = ignored
-  def readBigInt() = ignored
-  def readBigDecimal() = ignored
-  def skip() = ()
+
+  val somes: Seq[Option[String]] = MArrayBuffer.tabulate(1000)(i => Some(i.toString))
+  val nones: Seq[Option[String]] = MArrayBuffer.fill(1000)(None)
+
+  val options = JsonOptions(binaryFormat = JsonBinaryFormat.HexString)
+  val hex: String = JsonStringOutput.write(Array.tabulate[Byte](1024)(_.toByte), options)
 }

commons-benchmark/jvm/src/main/scala/com/avsystem/commons/ser/JsonSerializationBenchmark.scala

@@ -7,8 +7,8 @@ import io.circe.parser._
 import io.circe.syntax._
 import org.openjdk.jmh.annotations.{Benchmark, BenchmarkMode, Fork, Measurement, Mode, Warmup}
 
-@Warmup(iterations = 10)
-@Measurement(iterations = 20)
+@Warmup(iterations = 5, time = 1)
+@Measurement(iterations = 10, time = 2)
 @Fork(1)
 @BenchmarkMode(Array(Mode.Throughput))
 abstract class JsonSerializationBenchmark

commons-benchmark/src/main/scala/com/avsystem/commons/ser/CirceJsonInputOutput.scala

@@ -55,12 +55,7 @@ class CirceJsonInput(json: Json) extends Input {
 
   private def asNumber = json.asNumber.getOrElse(failNot("number"))
 
-  final def inputType: InputType =
-    if (json.isNull) InputType.Null
-    else if (json.isArray) InputType.List
-    else if (json.isObject) InputType.Object
-    else InputType.Simple
-
+  def isNull: Boolean = json.isNull
   def readNull(): Null = if (json.isNull) null else failNot("null")
   def readString(): String = json.asString.getOrElse(failNot("string"))
   def readBoolean(): Boolean = json.asBoolean.getOrElse(failNot("boolean"))

commons-core/js/src/main/scala/com/avsystem/commons/jsiop/JsInterop.scala

@@ -0,0 +1,12 @@
+package com.avsystem.commons
+package jsiop
+
+import com.avsystem.commons.misc.TimestampConversions
+
+import scala.scalajs.js
+
+trait JsInterop {
+  implicit def jsDateTimestampConversions(jsDate: js.Date): TimestampConversions =
+    new TimestampConversions(jsDate.getTime.toLong)
+}
+object JsInterop extends JsInterop

commons-core/js/src/main/scala/com/avsystem/commons/misc/TimestampConversions.scala

@@ -0,0 +1,10 @@
+package com.avsystem.commons
+package misc
+
+import scala.scalajs.js
+
+final class TimestampConversions(private val millis: Long) extends AnyVal {
+  def toTimestamp: Timestamp = Timestamp(millis)
+  def toJsDate: js.Date = new js.Date(millis.toDouble)
+  def toJDate: JDate = new JDate(millis)
+}

commons-core/js/src/main/scala/com/avsystem/commons/serialization/IsoInstant.scala

@@ -0,0 +1,24 @@
+package com.avsystem.commons
+package serialization
+
+import com.avsystem.commons.serialization.GenCodec.ReadFailure
+
+import scala.scalajs.js
+import scala.scalajs.js.RegExp
+
+object IsoInstant {
+  private val regex: RegExp =
+    js.RegExp("""^(\+|-)?[0-9]+-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(\.[0-9]{3})?Z$""")
+
+  def format(millis: Long): String =
+    new js.Date(millis.toDouble).toISOString
+
+  def parse(string: String): Long = {
+    def fail = throw new ReadFailure(s"invalid ISO instant: $string")
+    if (regex.test(string)) {
+      val parsed = js.Date.parse(string)
+      if (parsed.isNaN) fail
+      else parsed.toLong
+    } else fail
+  }
+}

commons-core/jvm/src/main/scala/com/avsystem/commons/jiop/JavaInterop.scala

@@ -12,5 +12,6 @@ trait JavaInterop extends AnyRef
   with JFunctionUtils
   with JStreamUtils
   with JOptionalUtils
+  with JavaTimeInterop
 
 object JavaInterop extends JavaInterop

commons-core/jvm/src/main/scala/com/avsystem/commons/jiop/JavaTimeInterop.scala

@@ -0,0 +1,17 @@
+package com.avsystem.commons
+package jiop
+
+import java.time.Instant
+
+import com.avsystem.commons.jiop.JavaTimeInterop.InstantOps
+import com.avsystem.commons.misc.Timestamp
+
+trait JavaTimeInterop {
+  implicit def instantOps(instant: Instant): InstantOps = new InstantOps(instant)
+}
+object JavaTimeInterop {
+  class InstantOps(private val instant: Instant) extends AnyVal {
+    def truncateToTimestamp: Timestamp = Timestamp(instant.toEpochMilli)
+    def truncateToJDate: JDate = new JDate(instant.toEpochMilli)
+  }
+}

commons-core/jvm/src/main/scala/com/avsystem/commons/jsiop/JsInterop.scala

@@ -0,0 +1,5 @@
+package com.avsystem.commons
+package jsiop
+
+trait JsInterop
+object JsInterop extends JsInterop

commons-core/jvm/src/main/scala/com/avsystem/commons/misc/TimestampConversions.scala

@@ -0,0 +1,10 @@
+package com.avsystem.commons
+package misc
+
+import java.time.Instant
+
+final class TimestampConversions(private val millis: Long) extends AnyVal {
+  def toTimestamp: Timestamp = Timestamp(millis)
+  def toInstant: Instant = Instant.ofEpochMilli(millis)
+  def toJDate: JDate = new JDate(millis)
+}

commons-core/jvm/src/main/scala/com/avsystem/commons/serialization/IsoInstant.scala

@@ -0,0 +1,21 @@
+package com.avsystem.commons
+package serialization
+
+import java.time.Instant
+import java.time.format.DateTimeParseException
+
+import com.avsystem.commons.serialization.GenCodec.ReadFailure
+
+object IsoInstant {
+  def format(millis: Long): String = {
+    val res = Instant.ofEpochMilli(millis).toString
+    // add trailing .000Z if omitted to align with JS implementation
+    if (res.charAt(res.length - 5) == '.') res
+    else res.substring(0, res.length - 1) + ".000Z"
+  }
+
+  def parse(string: String): Long =
+    try Instant.parse(string).toEpochMilli catch {
+      case _: DateTimeParseException => throw new ReadFailure(s"invalid ISO instant: $string")
+    }
+}

commons-core/src/main/scala/com/avsystem/commons/SharedExtensions.scala

@@ -68,6 +68,8 @@ object SharedExtensions extends SharedExtensions {
     @silent
     def discard: Unit = ()
 
+    def thenReturn[T](value: T): T = value
+
     def option: Option[A] = Option(a)
 
     def opt: Opt[A] = Opt(a)

commons-core/src/main/scala/com/avsystem/commons/jiop/JBasicUtils.scala

@@ -5,13 +5,16 @@ import java.util.Comparator
 import java.util.concurrent.Callable
 import java.{lang => jl, math => jm, util => ju}
 
-import com.avsystem.commons.misc.Sam
+import com.avsystem.commons.misc.{Sam, TimestampConversions}
 
 trait JBasicUtils {
   def jRunnable(code: => Any) = Sam[Runnable](code)
   def jCallable[T](expr: => T) = Sam[Callable[T]](expr)
   def jComparator[T](cmp: (T, T) => Int) = Sam[Comparator[T]](cmp)
 
+  implicit def jDateTimestampConversions(date: JDate): TimestampConversions =
+    new TimestampConversions(date.getTime)
+
   type JByte = jl.Byte
   type JShort = jl.Short
   type JInteger = jl.Integer

commons-core/src/main/scala/com/avsystem/commons/misc/BoxingUnboxing.scala

@@ -13,8 +13,8 @@ object Boxing extends LowPrioBoxing {
   implicit val FloatBoxing: Boxing[Float, JFloat] = fromImplicitConv
   implicit val DoubleBoxing: Boxing[Double, JDouble] = fromImplicitConv
 }
-trait LowPrioBoxing {this: Boxing.type =>
-  implicit def anyRefBoxing[A >: Null <: AnyRef]: Boxing[A, A] = Boxing(identity)
+trait LowPrioBoxing { this: Boxing.type =>
+  implicit def nullableBoxing[A >: Null]: Boxing[A, A] = Boxing(identity)
 }
 
 case class Unboxing[+A, -B](fun: B => A) extends AnyVal
@@ -29,6 +29,6 @@ object Unboxing extends LowPrioUnboxing {
   implicit val FloatUnboxing: Unboxing[Float, JFloat] = fromImplicitConv
   implicit val DoubleUnboxing: Unboxing[Double, JDouble] = fromImplicitConv
 }
-trait LowPrioUnboxing {this: Unboxing.type =>
-  implicit def anyRefUnboxing[A >: Null <: AnyRef]: Unboxing[A, A] = Unboxing(identity)
+trait LowPrioUnboxing { this: Unboxing.type =>
+  implicit def nullableUnboxing[A >: Null]: Unboxing[A, A] = Unboxing(identity)
 }

commons-core/src/main/scala/com/avsystem/commons/misc/Timestamp.scala

@@ -0,0 +1,48 @@
+package com.avsystem.commons
+package misc
+
+import com.avsystem.commons.serialization.{GenCodec, GenKeyCodec, IsoInstant}
+
+import scala.concurrent.duration.{FiniteDuration, TimeUnit}
+
+/**
+  * Millisecond-precision, general purpose, cross compiled timestamp representation.
+  *
+  * @param millis milliseconds since UNIX epoch, UTC
+  */
+class Timestamp(val millis: Long) extends AnyVal {
+  def toJDate: JDate = new JDate(millis)
+
+  def <(other: Timestamp): Boolean = millis < other.millis
+  def <=(other: Timestamp): Boolean = millis <= other.millis
+  def >(other: Timestamp): Boolean = millis > other.millis
+  def >=(other: Timestamp): Boolean = millis >= other.millis
+
+  def add(amount: Long, unit: TimeUnit): Timestamp = Timestamp(millis + unit.toMillis(amount))
+
+  def +(duration: FiniteDuration): Timestamp = Timestamp(millis + duration.toMillis)
+  def -(duration: FiniteDuration): Timestamp = Timestamp(millis - duration.toMillis)
+
+  override def toString: String = IsoInstant.format(millis)
+}
+object Timestamp {
+  final val Zero = Timestamp(0)
+
+  def apply(millis: Long): Timestamp = new Timestamp(millis)
+  def unapply(timestamp: Timestamp): Opt[Long] = Opt(timestamp.millis)
+  def parse(str: String): Timestamp = Timestamp(IsoInstant.parse(str))
+
+  def now(): Timestamp = Timestamp(System.currentTimeMillis())
+
+  implicit def conversions(tstamp: Timestamp): TimestampConversions =
+    new TimestampConversions(tstamp.millis)
+
+  implicit val keyCodec: GenKeyCodec[Timestamp] =
+    GenKeyCodec.create(parse, _.toString)
+
+  implicit val codec: GenCodec[Timestamp] =
+    GenCodec.create(i => Timestamp(i.readTimestamp()), (o, t) => o.writeTimestamp(t.millis))
+
+  implicit val ordering: Ordering[Timestamp] =
+    Ordering.by(_.millis)
+}

commons-core/src/main/scala/com/avsystem/commons/package.scala

@@ -2,6 +2,7 @@ package com.avsystem
 
 import com.avsystem.commons.collection.CollectionAliases
 import com.avsystem.commons.jiop.JavaInterop
+import com.avsystem.commons.jsiop.JsInterop
 
 package object commons
-  extends SharedExtensions with CommonAliases with CollectionAliases with JavaInterop
+  extends SharedExtensions with CommonAliases with CollectionAliases with JavaInterop with JsInterop