evolution-gaming / kryo-macros Goto Github PK

Scala macros for compile-time generation of Kryo serializers

License: Other

Scala 99.81% Java 0.19%

kryo-macros's Introduction

Kryo Macros

Scala macros that generate com.esotericsoftware.kryo.Serializer implementations in compile time, based on compile time reflection.

Features and limitations

On top level only case classes are supported
Fields of case classes can be other case classes, Scala collections, options, primitive or AnyVal types & classes, tuples, Scala enums, standard types & classes: String, Either, BigDecimal, java.time.Instant, scala.concurrent.duration.FiniteDuration, org.joda.time.DateTime
Fields can be annotated as transient or just be not defined in constructor to avoid parsing and serializing
For nested structures need to generate serializers for all case classes
Implicitly defined mapping helpers are supported for ADT structures, simple alternative mappings, etc.
Manual serializers can be used in generated code when defined as implicits

How to use

Add the following resolver

resolvers += Resolver.bintrayRepo("evolutiongaming", "maven")

Add the library to your dependencies list

libraryDependencies += "com.evolutiongaming" %% "kryo-macros" % "1.3.0"

Generate some serializers for your case classes

import com.evolutiongaming.kryo.Serializer

case class Player(name: String)

val serializer = Serializer.make[Player]

That's it! You have generated a com.esotericsoftware.kryo.Serializer implementation for your Player. You must know what to do with it if you are here :)

To serialize objects that extends sealed traits/class use Serializer.makeCommon call:

import com.evolutiongaming.kryo.{ConstSerializer, Serializer}
 
sealed trait Reason
 
object Reason {
  case object Close extends Reason
  case object Pause extends Reason       
}

val reasonSerializer = Serializer.makeCommon[Reason] {
  case 0 => ConstSerializer(Reason.Close)
  case 1 => ConstSerializer(Reason.Pause)
}

sealed abstract class Message(val text: String)

object Message {
  case object Common extends Message("common")
  case object Notification extends Message("notification")
}

private implicit val messageSerializer = Serializer.makeMapping[Message] {
  case 0 => Message.Common   
  case 1 => Message.Notification
}

To see generated code just add the following line to your sbt build file

scalacOptions += "-Xmacro-settings:print-serializers"

For more examples, please, check out SerializerMacroSpec

How to develop

Run tests, check coverage & binary compatibility for both supported Scala versions

sbt clean +coverage +test +coverageReport +mimaReportBinaryIssues

Run benchmarks

sbt -no-colors clean 'benchmark/jmh:run -prof gc .*SerializerBenchmark.*' >results.txt

Release

For version numbering use Recommended Versioning Scheme that is widely adopted in the Scala ecosystem.

Double-check binary & source compatibility and release using following command (credentials required):

sbt release

kryo-macros's People

Contributors

Stargazers

Watchers

Forkers

nau plokhotnyuk migesok tagtog scala-steward scrubbit

kryo-macros's Issues

Add support of recusive structures

Ordering is lost

When serializing a TreeMap (and probably TreeSet), the Ordering is lost silently.

Update README.md with newly supported types

OOM on some BigDecimal inputs during serialization

For a serializer generated for a case class which contains a BigDecimal field, if a number with sufficiently big scale supplied (like BigDecimal("3E1000000000")), serialization logic blows in memory causing OOM.
This could be a possible source for DoS attacks.

Separated benchmarks all supported classes and collections
Use parameterization for collections
Add real-world examples of messages, as example, for aggregated object and list of update events like here: https://github.com/plokhotnyuk/scala-serialization/blob/41adcf458b00b1630e5aa25d83c9a4c1ef621998/scala-serialization/src/main/scala/com/komanov/serialization/converters/KryoMacrosConverter.scala#L27-L71

Add support of any types on top-level

Use cases:

to allow serialization of collections and standard types on top-level and avoid redundant wrapping by case classes
to allow reuse generated serializers for collections and standard types in custom codecs

Publish 2.13.0 build

Please?

Support for Sealed Traits

Hello,

Is there support for de/serialization of sealed traits?

Thanks!

More compact binary representation

Consider more compact binary representation for:

smaller than Int primitive types (Byte, Short, Char, Boolean)
use variable length representation for primitive types and their collections (see current BitSet serializer implementation)

List: https://github.com/plokhotnyuk/jsoniter-scala/blob/master/macros/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/macros/JsonCodecMaker.scala#L819-L826
IndexedSeq: https://github.com/plokhotnyuk/jsoniter-scala/blob/master/macros/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/macros/JsonCodecMaker.scala#L828-L836
Use sizeHint for builders and mutable collections to minimize allocation during parsing

Depends on: #22