::Child
assertDifferent(indirectChildTag, directChildTag)
assertNotChild(directChildTag, indirectChildTag)
assertNotChild(indirectChildTag, directChildTag)
assertRepr(indirectChildTag, "path::Child")
}
}
}
================================================
FILE: izumi-reflect/izumi-reflect/src/test/scala-2.11/izumi/reflect/test/Scala2MinorVersion.scala
================================================
package izumi.reflect.test
object Scala2MinorVersion {
def scala2MinorVersion: Int = 11
}
================================================
FILE: izumi-reflect/izumi-reflect/src/test/scala-2.12/izumi/reflect/test/Scala2MinorVersion.scala
================================================
package izumi.reflect.test
object Scala2MinorVersion {
def scala2MinorVersion: Int = 12
}
================================================
FILE: izumi-reflect/izumi-reflect/src/test/scala-2.13/izumi/reflect/test/Scala2MinorVersion.scala
================================================
package izumi.reflect.test
object Scala2MinorVersion {
def scala2MinorVersion: Int = 13
}
================================================
FILE: izumi-reflect/izumi-reflect/src/test/scala-2.13+/izumi/reflect/test/Scala213Plus_LightTypeTagTest.scala
================================================
package izumi.reflect.test
import org.scalatest.wordspec.AnyWordSpec
import izumi.reflect.macrortti.LTT
class Scala213Plus_LightTypeTagTest extends AnyWordSpec with TagAssertions with TagProgressions {
"lightweight type tags (2.13+)" should {
"literal types behave in sane manner https://github.com/zio/izumi-reflect/issues/284" in {
import izumi.reflect._
val v: "a" = "a"
type vt = v.type
object xa {
final val x = v
final val y = x
}
assertSameStrict(Tag["a"].tag, Tag[vt].tag)
assertSameStrict(Tag[xa.x.type].tag, Tag["a"].tag)
assertSameStrict(Tag[xa.y.type].tag, Tag["a"].tag)
assertDebugSame(Tag["a"].tag, Tag[vt].tag)
assertDebugSame(Tag[xa.x.type].tag, Tag["a"].tag)
assertDebugSame(Tag[xa.y.type].tag, Tag["a"].tag)
assertChildStrict(Tag["a"].tag, Tag[String].tag)
assertChildStrict(Tag[vt].tag, Tag[String].tag)
assertChildStrict(Tag[xa.x.type].tag, Tag[String].tag)
assertChildStrict(Tag[xa.y.type].tag, Tag[String].tag)
}
"support string constant types (Scala 2.13+ syntax)" in {
assertDifferent(LTT["abc"], LTT[String])
assertDifferent(LTT["abc"], LTT["cba"])
assertSameStrict(LTT["abc"], LTT["abc"])
assertChildStrict(LTT["abc"], LTT[String])
}
}
}
================================================
FILE: izumi-reflect/izumi-reflect/src/test/scala-3/izumi/reflect/test/BasicDottyTest.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package izumi.reflect.test
class BasicDottyTest extends CurrentDottySupportExtentTest
================================================
FILE: izumi-reflect/izumi-reflect/src/test/scala-3/izumi/reflect/test/DiscoveryModel.scala
================================================
package izumi.reflect.test
object DiscoveryModel {
trait NodeId
trait DiscoverableService {
type DiscoveryNode <: NodeId
}
trait DiscoveryNodeProvider[Id <: NodeId]
trait DiscoverableServiceImpl extends DiscoverableService {
override type DiscoveryNode = NodeIdImpl
}
class NodeIdImpl extends NodeId
type GetDiscoveryNode[T <: DiscoverableService] <: NodeId = T match {
case GetDiscoveryNodePattern[t] => t
}
type GetDiscoveryNodePattern[Id <: NodeId] = DiscoverableService { type DiscoveryNode = Id }
}
================================================
FILE: izumi-reflect/izumi-reflect/src/test/scala-3/izumi/reflect/test/DottyRegressionTests.scala
================================================
package izumi.reflect.test
import izumi.reflect.Tag
object DottyRegressionTests {
// should compile
// https://github.com/zio/izumi-reflect/issues/135#issue-801046733
import zio._
trait DgraphClient
object Example extends scala.App {
type DgClient = Has[DgClient.Service]
object DgClient {
trait Service {
val dgraphClient: UIO[DgraphClient]
}
val getDgClient =
ZIO.accessM[DgClient](_.get.dgraphClient)
}
}
object zio {
type UIO[+A] = ZIO[Any, Nothing, A]
sealed trait ZIO[-R, +E, +A]
object ZIO {
def accessM[R]: AccessMPartiallyApplied[R] = new AccessMPartiallyApplied[R]()
final class AccessMPartiallyApplied[R](private val dummy: Boolean = false) extends AnyVal {
def apply[E, A](f: R => ZIO[R, E, A]): ZIO[R, E, A] = ???
}
}
trait Has[A]
object Has {
implicit final class HasSyntax[Self <: Has[_]](private val self: Self) extends AnyVal {
def get[B](implicit ev: Self <:< Has[B], tagged: Tag[B]): B = ???
}
}
}
}
================================================
FILE: izumi-reflect/izumi-reflect/src/test/scala-3/izumi/reflect/test/IsScala3.scala
================================================
package izumi.reflect.test
inline val IsScala3 = true
================================================
FILE: izumi-reflect/izumi-reflect/src/test/scala-3/izumi/reflect/test/LightTypeTagProgressionTest.scala
================================================
package izumi.reflect.test
import izumi.reflect.macrortti._
class LightTypeTagProgressionTest extends SharedLightTypeTagProgressionTest {
"[progression] lightweight type tag (Dotty)" should {
"fails to support variance for type parameters of opaque types" in {
object x {
opaque type T[+X] = X
}
broken {
assertChildStrict(LTT[x.T[Int]], LTT[x.T[AnyVal]])
}
}
}
}
================================================
FILE: izumi-reflect/izumi-reflect/src/test/scala-3/izumi/reflect/test/LightTypeTagTest.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package izumi.reflect.test
import izumi.reflect.Tag
import izumi.reflect.macrortti.*
import izumi.reflect.macrortti.LightTypeTagRef.{AbstractReference, AppliedNamedReference, Boundaries, Lambda}
import scala.collection.immutable.ListSet
import scala.collection.{BitSet, immutable, mutable}
class LightTypeTagTest extends SharedLightTypeTagTest {
import TestModel._
"lightweight type tags (Dotty)" should {
"tautological intersections with Matchable are discarded from internal structure (Scala 3 specific, Matchable)" in {
assertSameStrict(LTT[Matchable with Option[String]], LTT[Option[String]])
assertDebugSame(LTT[Matchable with Option[String]], LTT[Option[String]])
}
"tautological intersections with Matchable are discarded from internal structure (Scala 3 specific, Matchable) (Tag)" in {
assertSameStrict(Tag[Matchable with Option[String]].tag, LTT[Option[String]])
assertDebugSame(Tag[Matchable with Option[String]].tag, LTT[Option[String]])
}
"tautological unions with Any/AnyRef/Matchable/Object are discarded from internal structure (Scala 3 specific, Matchable)" in {
assertSameStrict(LTT[Any | Matchable | AnyRef | Object | Option[String] | Nothing], LTT[Any])
assertDebugSame(LTT[Any | Matchable | AnyRef | Object | Option[String] | Nothing], LTT[Any])
assertSameStrict(LTT[Matchable | AnyRef | Object | Option[String] | Nothing], LTT[Matchable])
assertDebugSame(LTT[Matchable | AnyRef | Object | Option[String] | Nothing], LTT[Matchable])
assertSameStrict(LTT[AnyRef | Object | Option[String] | Nothing], LTT[AnyRef])
assertDebugSame(LTT[AnyRef | Object | Option[String] | Nothing], LTT[AnyRef])
assertSameStrict(LTT[Object | Option[String] | Nothing], LTT[Object])
assertDebugSame(LTT[Object | Option[String] | Nothing], LTT[Object])
assertSameStrict(LTT[Option[String] | Nothing], LTT[Option[String]])
assertDebugSame(LTT[Option[String] | Nothing], LTT[Option[String]])
}
"tautological unions with Any/AnyRef/Matchable/Object are discarded from internal structure (Scala 3 specific, Matchable) (Tag)" in {
assertSameStrict(Tag[Any | Matchable | AnyRef | Object | Option[String] | Nothing].tag, LTT[Any])
assertDebugSame(Tag[Any | Matchable | AnyRef | Object | Option[String] | Nothing].tag, LTT[Any])
assertSameStrict(Tag[Matchable | AnyRef | Object | Option[String] | Nothing].tag, LTT[Matchable])
assertDebugSame(Tag[Matchable | AnyRef | Object | Option[String] | Nothing].tag, LTT[Matchable])
assertSameStrict(Tag[AnyRef | Object | Option[String] | Nothing].tag, LTT[AnyRef])
assertDebugSame(Tag[AnyRef | Object | Option[String] | Nothing].tag, LTT[AnyRef])
assertSameStrict(Tag[Object | Option[String] | Nothing].tag, LTT[Object])
assertDebugSame(Tag[Object | Option[String] | Nothing].tag, LTT[Object])
assertSameStrict(Tag[Option[String] | Nothing].tag, LTT[Option[String]])
assertDebugSame(Tag[Option[String] | Nothing].tag, LTT[Option[String]])
}
"support top-level abstract types (Scala 3 specific, top level type aliases)" in {
assertChildStrict(LTT[LightTypeTagTestT], LTT[String])
}
"support opaque types" in {
object x {
type T >: List[Int] <: List[Int]
opaque type Opaque = List[Int]
opaque type OpaqueSub <: List[Int] = List[Int]
}
assertNotChildStrict(LTT[x.Opaque], LTT[List[Int]])
assertNotChildStrict(LTT[x.Opaque], LTT[Seq[Int]])
assertNotChildStrict(LTT[x.Opaque], LTT[x.T])
assertNotChildStrict(LTT[x.Opaque], LTT[x.OpaqueSub])
assertChildStrict(LTT[x.OpaqueSub], LTT[List[Int]])
assertChildStrict(LTT[x.OpaqueSub], LTT[Seq[Int]])
assertChildStrict(LTT[x.T], LTT[Seq[Int]])
assertChildStrict(LTT[x.OpaqueSub], LTT[x.T])
assertDifferent(LTT[x.OpaqueSub], LTT[x.T])
}
"basic support for polymorphic function types" in {
val t1 = LTT[[A] => A => A]
val t2 = LTT[[B] => B => B]
assertSameStrict(t1, t2)
}
}
}
type LightTypeTagTestT <: String
================================================
FILE: izumi-reflect/izumi-reflect/src/test/scala-3/izumi/reflect/test/PlatformSpecific.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package izumi.reflect.test
import izumi.reflect.dottyreflection.Inspect
import izumi.reflect.macrortti.LightTypeTag
object PlatformSpecific {
inline def fromRuntime[T]: LightTypeTag = Inspect.inspect[T]
inline def fromRuntime[T](loud: Boolean): LightTypeTag = Inspect.inspect[T]
}
================================================
FILE: izumi-reflect/izumi-reflect/src/test/scala-3/izumi/reflect/test/Scala2MinorVersion.scala
================================================
package izumi.reflect.test
object Scala2MinorVersion {
def scala2MinorVersion: Int = -1
}
================================================
FILE: izumi-reflect/izumi-reflect/src/test/scala-3/izumi/reflect/test/TagProgressionTest.scala
================================================
package izumi.reflect.test
import izumi.reflect.Tag
import izumi.reflect.test.TestModel.*
class TagProgressionTest extends SharedTagProgressionTest {
"[progression] Tag (Dotty)" should {
// Can't fix this atm because simplification happens even without .simplified call because of https://github.com/lampepfl/dotty/issues/17544
"progression test: fails to don't lose tautological union components other than Nothing" in {
def tag1[T: Tag]: Tag[T | Trait1] = Tag[T | Trait1]
def tag4[T: Tag]: Tag[T | Trait4] = Tag[T | Trait4]
val t1 = tag1[Trait3[Dep]].tag
val t2 = tag4[Trait3[Dep]].tag
val t10 = Tag[Trait3[Dep] | Trait1].tag
val t20 = Tag[Trait3[Dep] | Trait4].tag
brokenOnScala3 {
assertSameStrict(t1, t10)
assertDebugSame(t1, t10)
}
assertSameStrict(t2, t20)
assertDebugSame(t2, t20)
}
// We don't really want to fix it, because removing tautologies is quadratic, with two subtyping comparisions per step!
// Would make construction really expensive, all for an extremely rare corner case
"progression test: union tautologies are not removed automatically when constructing combined union type" in {
def tag1[T: Tag]: Tag[T | Trait1] = Tag[T | Trait1]
val t1 = tag1[Trait3[Dep]].tag
val t10 = t1.removeUnionTautologies
brokenOnScala3 {
assertSameStrict(t1, t10)
assertDebugSame(t1, t10)
}
}
}
}
================================================
FILE: izumi-reflect/izumi-reflect/src/test/scala-3/izumi/reflect/test/TagTest.scala
================================================
package izumi.reflect.test
import izumi.reflect.macrortti.{LTT, LTag}
import izumi.reflect.{HKTag, Tag, TagK, TagTK}
import izumi.reflect.test.ID.*
import izumi.reflect.test.PlatformSpecific.fromRuntime
import izumi.reflect.test.TestModel.{Trait1, Trait3, Trait4}
import org.scalatest.exceptions.TestFailedException
class TagTest extends SharedTagTest with TagAssertions {
override final val tagZ = Tag[String]
trait Trait1 {
def dep: Dep
}
trait Trait3[T <: Dep] extends Trait1 {
def dep: T
}
"Tag (Dotty)" should {
"Support union subtyping (Scala 3 specific, union types)" in {
trait Animal
trait Dog extends Animal
assertChild(Tag[Dog].tag, Tag[Animal].tag)
assertChild(Tag[Dog | String].tag, Tag[Animal | String].tag)
assertNotChild(Tag[Animal | String].tag, Tag[Dog | String].tag)
}
"Can create custom type tags to support bounded generics, e.g. <: Dep in TagK (Scala 3 HKTag Syntax)" in {
type `TagK<:Dep`[K[_ <: Dep]] = Tag[K]
implicitly[`TagK<:Dep`[Trait3]].tag.withoutArgs =:= LTag[Trait3[Nothing]].tag.withoutArgs
}
"combine union types (Scala 3 specific, union types)" in {
def t1[A: Tag] = Tag[String | A]
def t2[A: Tag, B: Tag] = Tag[A | B]
assertSameStrict(t1[Int].tag, Tag[Int | String].tag)
assertSameStrict(t2[Int, String].tag, Tag[String | Int].tag)
assertSameStrict(t1[String].tag, Tag[String].tag)
assertSameStrict(t2[String, String].tag, Tag[String].tag)
}
"type tags with bounds are successfully requested by TagMacro" in {
type `TagK<:Dep`[K[_ <: Dep]] = Tag.auto.T[K]
def t[T[_ <: Dep]: `TagK<:Dep`, A <: Dep: Tag] = Tag[T[A]]
assertSameStrict(t[Trait3, Dep].tag, Tag[Trait3[Dep]].tag)
}
"remove tautological unions with Nothing (LTT)" in {
assertSameStrict(LTT[Nothing | Option[String]], LTT[Option[String]])
}
"remove tautological unions with Nothing (Tag)" in {
assertSameStrict(Tag[Nothing | Option[String]].tag, LTT[Option[String]])
}
"combine intersection path-dependent intersection types with inner tags works on Scala 3" in {
trait PDT {
type T
implicit def tag: Tag[T]
def badCombine(that: PDT): Tag[T with that.T] = {
Tag[T with that.T]
}
def goodCombine(that: PDT): Tag[T with that.T] = {
import that.tag
Tag[T with that.T]
}
}
def PDT[U: Tag]: PDT = new PDT { type T = U; override val tag: Tag[U] = Tag[U] }
val badCombine = PDT[Int].badCombine(PDT[Unit])
assertSameStrict(badCombine.tag, Tag[Int with Unit].tag)
val goodCombine = PDT[Int].goodCombine(PDT[Unit])
assertSameStrict(goodCombine.tag, Tag[Int with Unit].tag)
}
}
}
trait Layer[A] {
def tag: Tag[A]
}
object Layer {
def succeed[A: Tag](value: => A): Layer[A] =
new Layer[A] {
override def tag: Tag[A] = implicitly
}
}
// should compile
// Example from here: https://github.com/zio/zio/issues/6071
object CachedRefinedTypeExample {
trait Animal
trait Dog extends Animal
trait Service {
def animal: Animal
}
val layer =
Layer.succeed {
new Service {
def animal: Dog = new Dog {}
}
}
}
================================================
FILE: izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/.js/src/main/scala/izumi/reflect/thirdparty/internal/boopickle/ReferenceEquality.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package izumi.reflect.thirdparty.internal.boopickle
private[boopickle] object ReferenceEquality {
@inline def eq(a: AnyRef, b: AnyRef): Boolean = a eq b
@inline def ne(a: AnyRef, b: AnyRef): Boolean = a ne b
@inline def identityHashCode(obj: AnyRef): Int = System.identityHashCode(obj)
}
================================================
FILE: izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/.js/src/main/scala/izumi/reflect/thirdparty/internal/boopickle/StringCodec.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package izumi.reflect.thirdparty.internal.boopickle
import java.nio.ByteBuffer
import java.nio.charset.StandardCharsets
import scala.scalajs.js
import scala.scalajs.js.annotation.JSGlobal
import scala.scalajs.js.typedarray.TypedArrayBufferOps._
import scala.scalajs.js.typedarray._
/**
* This is a fork-point from original `boopickle` codebase.
*
* LightTypeTags are encoded at compile-time and decoded at run-time,
* but Scala does not use the JVM version of the artifact to run macros
* from. Instead it tries to run the Scala.js version compiled for JVM,
* but the optimized encoder in boopickle is using native JavaScript classes
* so it can't work.
*
* Here we include both the JVM and JS versions of StringCodec and use the JVM
* version for encode* methods and JS version for decode* methods.
*/
private[reflect] object StringCodec extends StringCodecBase {
@inline override def decodeFast(len: Int, buf: ByteBuffer): String = {
JSStringCodec.decodeFast(len, buf)
}
@inline override def decodeUTF8(len: Int, buf: ByteBuffer): String = {
JSStringCodec.decodeUTF8(len, buf)
}
@inline override def decodeUTF16(len: Int, buf: ByteBuffer): String = {
JSStringCodec.decodeUTF16(len, buf)
}
@inline override def encodeUTF8(str: String): ByteBuffer = {
JVMStringCodec.encodeUTF8(str)
}
@inline override def encodeUTF16(str: String): ByteBuffer = {
JVMStringCodec.encodeUTF16(str)
}
}
/**
* This is a fork-point from original `boopickle` codebase.
*
* ByteBufferProvider is only used for encoding. JVM encoder is incompatible with `DirectByteBufferProvider`,
* so use `HeapByteBufferProvider`
*/
private[reflect] object DefaultByteBufferProvider extends DefaultByteBufferProviderFuncs {
// override def provider = new DirectByteBufferProvider
override def provider = new HeapByteBufferProvider
}
private[boopickle] object JVMStringCodec extends StringCodecBase {
override def decodeUTF8(len: Int, buf: ByteBuffer): String = {
val a = new Array[Byte](len)
buf.get(a)
new String(a, StandardCharsets.UTF_8)
}
override def encodeUTF8(str: String): ByteBuffer = {
ByteBuffer.wrap(str.getBytes(StandardCharsets.UTF_8))
}
override def decodeUTF16(len: Int, buf: ByteBuffer): String = {
val a = new Array[Byte](len)
buf.get(a)
new String(a, StandardCharsets.UTF_16LE)
}
override def encodeUTF16(str: String): ByteBuffer = {
ByteBuffer.wrap(str.getBytes(StandardCharsets.UTF_16LE))
}
}
/**
* Facade for native JS engine provided TextDecoder
*/
@js.native
@JSGlobal
private[boopickle] class TextDecoder(utfLabel: js.UndefOr[String] = js.undefined) extends js.Object {
def decode(data: ArrayBufferView): String = js.native
}
/**
* Facade for native JS engine provided TextEncoder
*/
@js.native
@JSGlobal
private[boopickle] class TextEncoder(utfLabel: js.UndefOr[String] = js.undefined) extends js.Object {
def encode(str: String): Int8Array = js.native
}
private[boopickle] object JSStringCodec extends StringCodecBase {
private lazy val utf8decoder: (Int8Array) => String = {
val td = new TextDecoder
// use native TextDecoder
(data: Int8Array) => td.decode(data)
}
private lazy val utf8encoder: (String) => Int8Array = {
val te = new TextEncoder
// use native TextEncoder
(str: String) => new Int8Array(te.encode(str))
}
private lazy val utf16decoder: (Uint16Array) => String = {
/*
try {
// do not use native TextDecoder as it's slow
val td = new TextDecoder("utf-16none")
(data: Uint16Array) => td.decode(data)
} catch {
case e: Throwable =>
*/
(data: Uint16Array) =>
js.Dynamic.global.String.fromCharCode.applyDynamic("apply")(null, data).asInstanceOf[String]
}
private lazy val utf16encoder: (String) => Int8Array = {
/*
try {
// do not use native TextEncoder as it's slow
val te = new TextEncoder("utf-16none")
(str: String) => te.encode(str)
} catch {
case e: Throwable =>
}
*/
(str: String) =>
{
val ta = new Uint16Array(str.length)
var i = 0
while (i < str.length) {
ta(i) = str.charAt(i).toInt
i += 1
}
new Int8Array(ta.buffer)
}
}
override def decodeUTF8(len: Int, buf: ByteBuffer): String = {
if (buf.isDirect && !js.isUndefined(js.Dynamic.global.TextDecoder)) {
// get the underlying Int8Array
val ta = buf.typedArray()
val s = utf8decoder(ta.subarray(buf.position(), buf.position() + len))
(buf: java.nio.Buffer).position(buf.position() + len)
s
} else {
val a = new Array[Byte](len)
buf.get(a)
new String(a, StandardCharsets.UTF_8)
}
}
override def encodeUTF8(str: String): ByteBuffer = {
if (js.isUndefined(js.Dynamic.global.TextEncoder)) {
ByteBuffer.wrap(str.getBytes(StandardCharsets.UTF_8))
} else {
TypedArrayBuffer.wrap(utf8encoder(str))
}
}
override def decodeUTF16(len: Int, buf: ByteBuffer): String = {
if (buf.isDirect) {
val ta = new Uint16Array(buf.typedArray().buffer, buf.position() + buf.typedArray().byteOffset, len / 2)
(buf: java.nio.Buffer).position(buf.position() + len)
utf16decoder(ta)
// new String(ta.toArray) // alt implementation
} else {
val a = new Array[Byte](len)
buf.get(a)
new String(a, StandardCharsets.UTF_16LE)
}
}
override def encodeUTF16(str: String): ByteBuffer = {
TypedArrayBuffer.wrap(utf16encoder(str))
}
override def decodeFast(len: Int, buf: ByteBuffer): String = {
if (buf.hasArray)
decodeFastArray(len, buf)
else
decodeFastTypedArray(len, buf)
}
override def encodeFast(s: String, bb: ByteBuffer): Unit = {
if (bb.hasArray)
encodeFastArray(s, bb)
else
encodeFastTypedArray(s, bb)
}
protected def encodeFastTypedArray(s: String, bb: ByteBuffer): Unit = {
val len = s.length()
val buf = bb.typedArray()
var dst = bb.position()
var src = 0
var c: Char = ' '
// start by encoding ASCII only
while ((src < len) && { c = s.charAt(src); c < 0x80 }) {
buf(dst) = c.toByte
src += 1
dst += 1
}
// next stage, encode also non-ASCII
while (src < len) {
c = s.charAt(src)
if (c < 0x80) {
buf(dst) = c.toByte
dst += 1
} else if (c < 0x4000) {
buf(dst) = (0x80 | (c & 0x3F)).toByte
buf(dst + 1) = (c >> 6 & 0xFF).toByte
dst += 2
} else {
buf(dst) = (0xC0 | (c & 0x3F)).toByte
buf(dst + 1) = (c >> 6 & 0xFF).toByte
buf(dst + 2) = (c >> 14).toByte
dst += 3
}
src += 1
}
(bb: java.nio.Buffer).position(dst)
}
private def charArray2String(chars: js.Array[Int], offset: Int, len: Int): String = {
// for some reason, on Chrome, calling `cp.jsSlice` makes `fromCharCode` 2-3x faster!
js.Dynamic.global.String.fromCharCode
.applyDynamic("apply")(null, chars.jsSlice(offset, offset + len))
.asInstanceOf[String]
}
protected def decodeFastTypedArray(len: Int, buf: ByteBuffer): String = {
val cp = new js.Array[Int](len)
val src = buf.typedArray()
var offset = buf.position()
var dst = 0
while (dst < len) {
val b = src(offset) & 0xFF
offset += 1
if ((b & 0x80) == 0) {
cp(dst) = b
} else if ((b & 0xC0) == 0x80) {
val b1 = src(offset) & 0xFF
offset += 1
cp(dst) = b & 0x3F | b1 << 6
} else {
val b1 = src(offset) & 0xFF
val b2 = src(offset + 1) & 0xFF
offset += 2
cp(dst) = b & 0x3F | b1 << 6 | b2 << 14
}
dst += 1
}
(buf: java.nio.Buffer).position(offset)
// for really long strings, convert in pieces to avoid JS engine overflows
if (len > 4096) {
offset = 0
var s = ""
while (offset < len) {
s += charArray2String(cp, offset, math.min(4096, len - offset))
offset += 4096
}
s
} else {
charArray2String(cp, 0, len)
}
}
}
================================================
FILE: izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/.jvm/src/main/scala/izumi/reflect/thirdparty/internal/boopickle/DefaultByteBufferProvider.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package izumi.reflect.thirdparty.internal.boopickle
private[reflect] object DefaultByteBufferProvider extends DefaultByteBufferProviderFuncs {
override def provider = new HeapByteBufferProvider
}
================================================
FILE: izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/.jvm/src/main/scala/izumi/reflect/thirdparty/internal/boopickle/ReferenceEquality.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package izumi.reflect.thirdparty.internal.boopickle
private[boopickle] object ReferenceEquality {
@inline def eq(a: AnyRef, b: AnyRef): Boolean = a eq b
@inline def ne(a: AnyRef, b: AnyRef): Boolean = a ne b
@inline def identityHashCode(obj: AnyRef): Int = System.identityHashCode(obj)
}
================================================
FILE: izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/.jvm/src/main/scala/izumi/reflect/thirdparty/internal/boopickle/StringCodec.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package izumi.reflect.thirdparty.internal.boopickle
import java.nio.ByteBuffer
import java.nio.charset.StandardCharsets
private[reflect] object StringCodec extends StringCodecBase {
override def decodeUTF8(len: Int, buf: ByteBuffer): String = {
val a = new Array[Byte](len)
buf.get(a)
new String(a, StandardCharsets.UTF_8)
}
override def encodeUTF8(str: String): ByteBuffer = {
ByteBuffer.wrap(str.getBytes(StandardCharsets.UTF_8))
}
override def decodeUTF16(len: Int, buf: ByteBuffer): String = {
val a = new Array[Byte](len)
buf.get(a)
new String(a, StandardCharsets.UTF_16LE)
}
override def encodeUTF16(str: String): ByteBuffer = {
ByteBuffer.wrap(str.getBytes(StandardCharsets.UTF_16LE))
}
}
================================================
FILE: izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/.native/src/main/scala/izumi/reflect/thirdparty/internal/boopickle/DefaultByteBufferProvider.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package izumi.reflect.thirdparty.internal.boopickle
object DefaultByteBufferProvider extends DefaultByteBufferProviderFuncs {
override def provider = new HeapByteBufferProvider
}
================================================
FILE: izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/.native/src/main/scala/izumi/reflect/thirdparty/internal/boopickle/ReferenceEquality.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package izumi.reflect.thirdparty.internal.boopickle
object ReferenceEquality {
@inline def eq(a: AnyRef, b: AnyRef): Boolean = a == b
@inline def ne(a: AnyRef, b: AnyRef): Boolean = a != b
@inline def identityHashCode(obj: AnyRef): Int = obj.hashCode()
}
================================================
FILE: izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/.native/src/main/scala/izumi/reflect/thirdparty/internal/boopickle/StringCodec.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package izumi.reflect.thirdparty.internal.boopickle
import java.nio.ByteBuffer
import java.nio.charset.StandardCharsets
object StringCodec extends StringCodecBase {
override def decodeUTF8(len: Int, buf: ByteBuffer): String = {
val a = new Array[Byte](len)
buf.get(a)
new String(a, StandardCharsets.UTF_8)
}
override def encodeUTF8(str: String): ByteBuffer = {
ByteBuffer.wrap(str.getBytes(StandardCharsets.UTF_8))
}
override def decodeUTF16(len: Int, buf: ByteBuffer): String = {
val a = new Array[Byte](len)
buf.get(a)
new String(a, StandardCharsets.UTF_16LE)
}
override def encodeUTF16(str: String): ByteBuffer = {
ByteBuffer.wrap(str.getBytes(StandardCharsets.UTF_16LE))
}
}
================================================
FILE: izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/src/main/scala/izumi/reflect/thirdparty/internal/boopickle/BufferPool.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package izumi.reflect.thirdparty.internal.boopickle
import java.nio.ByteBuffer
import java.util.concurrent.atomic.AtomicInteger
private[reflect] object BufferPool {
// two pools for two different size categories
private final val poolEntrySize0 = ByteBufferProvider.initSize
private final val poolEntrySize1 = ByteBufferProvider.expandSize + 16
// maximum size of a ByteBuffer to be included in a pool
private final val maxBufferSize = poolEntrySize1 * 2
private final val entryCount = 1024
private var disablePool = false
final class Pool {
private val pool0 = new Array[ByteBuffer](entryCount)
private val pool1 = new Array[ByteBuffer](entryCount)
private val allocIdx0 = new AtomicInteger(0)
private val allocIdx1 = new AtomicInteger(0)
private val releaseIdx0 = new AtomicInteger(0)
private val releaseIdx1 = new AtomicInteger(0)
// for collecting some performance characteristics
var allocOk = 0
var allocMiss = 0
def allocate(minSize: Int): Option[ByteBuffer] = {
if (disablePool) {
None
} else if (minSize > poolEntrySize1) {
allocMiss += 1
None
} else if (minSize > poolEntrySize0 || allocIdx0.get() == releaseIdx0.get()) {
// allocate from pool1
val aIdx = allocIdx1.get()
val rIdx = releaseIdx1.get()
val aNext = (aIdx + 1) % entryCount
if (aIdx != rIdx) {
// try to allocate
val result = Some(pool1(aNext))
if (allocIdx1.compareAndSet(aIdx, aNext)) {
allocOk += 1
result
} else {
allocMiss += 1
None
}
} else {
allocMiss += 1
None
}
} else {
// allocate from pool0
val aIdx = allocIdx0.get()
val rIdx = releaseIdx0.get()
val aNext = (aIdx + 1) % entryCount
if (aIdx != rIdx) {
// try to allocate
val result = Some(pool0(aNext))
if (allocIdx0.compareAndSet(aIdx, aNext)) {
allocOk += 1
result
} else {
allocMiss += 1
None
}
} else {
allocMiss += 1
None
}
}
}
def release(bb: ByteBuffer): Unit = {
if (!disablePool) {
// do not take large buffers into the pool, as their reallocation is relatively cheap
val bufSize = bb.capacity
if (bufSize < maxBufferSize && bufSize >= poolEntrySize0) {
if (bufSize >= poolEntrySize1) {
val aIdx = allocIdx1.get()
val rIdx = releaseIdx1.get()
val rNext = (rIdx + 1) % entryCount
if (rNext != aIdx) {
// try to release the buffer
(bb: java.nio.Buffer).clear()
pool1(rNext) = bb
releaseIdx1.compareAndSet(rIdx, rNext)
()
}
} else {
val aIdx = allocIdx0.get()
val rIdx = releaseIdx0.get()
val rNext = (rIdx + 1) % entryCount
if (rNext != aIdx) {
// try to release the buffer
(bb: java.nio.Buffer).clear()
pool0(rNext) = bb
releaseIdx0.compareAndSet(rIdx, rNext)
()
}
}
}
}
}
}
val heapPool = new Pool
val directPool = new Pool
def allocate(minSize: Int): Option[ByteBuffer] = {
heapPool.allocate(minSize)
}
def allocateDirect(minSize: Int): Option[ByteBuffer] = {
directPool.allocate(minSize)
}
def release(bb: ByteBuffer): Unit = {
if (bb.isDirect)
directPool.release(bb)
else
heapPool.release(bb)
}
def isDisabled = disablePool
def disable(): Unit = disablePool = true
def enable(): Unit = disablePool = false
def allocOk = heapPool.allocOk + directPool.allocOk
def allocMiss = heapPool.allocMiss + directPool.allocMiss
}
================================================
FILE: izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/src/main/scala/izumi/reflect/thirdparty/internal/boopickle/BufferProvider.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package izumi.reflect.thirdparty.internal.boopickle
import java.nio.{ByteBuffer, ByteOrder}
private[reflect] trait BufferProvider {
/**
* Makes sure the ByteBuffer has enough space for new data. If not, allocates a new ByteBuffer
* and returns it. The returned ByteBuffer must have little-endian ordering.
*
* @param size Number of bytes needed for new data
* @return
*/
def alloc(size: Int): ByteBuffer
/**
* Completes the encoding and returns the ByteBuffer, merging the chain of buffers if necessary
*
* @return
*/
def asByteBuffer: ByteBuffer
}
private[reflect] abstract class ByteBufferProvider extends BufferProvider {
import ByteBufferProvider._
protected val pool = BufferPool
protected var buffers: List[ByteBuffer] = Nil
protected var currentBuf: ByteBuffer = allocate(initSize)
protected def allocate(size: Int): ByteBuffer
final private def newBuffer(size: Int): Unit = {
// flip current buffer (prepare for reading and set limit)
(currentBuf: java.nio.Buffer).flip()
buffers = currentBuf :: buffers
// replace current buffer with the new one, align to 16-byte border for small sizes
currentBuf = allocate((math.max(size, expandSize) & ~15) + 16)
}
@inline final def alloc(size: Int): ByteBuffer = {
if (currentBuf.remaining() < size)
newBuffer(size)
currentBuf
}
def asByteBuffer = {
(currentBuf: java.nio.Buffer).flip()
if (buffers.isEmpty) currentBuf
else {
val bufList = (currentBuf :: buffers).reverse
// create a new buffer and combine all buffers into it
val comb = allocate(bufList.map(_.limit()).sum)
bufList.foreach(buf => comb.put(buf))
(comb: java.nio.Buffer).flip()
comb
}
}
}
private[reflect] object ByteBufferProvider {
final val initSize = 512
final val expandSize = initSize * 8
}
private[reflect] class HeapByteBufferProvider extends ByteBufferProvider {
override protected def allocate(size: Int) = {
if (pool.isDisabled)
ByteBuffer.allocate(size).order(ByteOrder.LITTLE_ENDIAN)
else
pool.allocate(size).getOrElse(ByteBuffer.allocate(size).order(ByteOrder.LITTLE_ENDIAN))
}
override def asByteBuffer = {
(currentBuf: java.nio.Buffer).flip()
if (buffers.isEmpty) currentBuf
else {
// create a new buffer and combine all buffers into it
val bufList = (currentBuf :: buffers).reverse
val comb = allocate(bufList.map(_.limit()).sum)
bufList.foreach {
buf =>
// use fast array copy
java.lang.System.arraycopy(buf.array(), buf.arrayOffset(), comb.array(), comb.position(), buf.limit())
(comb: java.nio.Buffer).position(comb.position() + buf.limit())
// release to the pool
pool.release(buf)
}
(comb: java.nio.Buffer).flip()
comb
}
}
}
private[reflect] trait DefaultByteBufferProviderFuncs {
def provider: ByteBufferProvider
}
================================================
FILE: izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/src/main/scala/izumi/reflect/thirdparty/internal/boopickle/CodecSize.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package izumi.reflect.thirdparty.internal.boopickle
import java.nio.ByteBuffer
private[reflect] class DecoderSize(val buf: ByteBuffer) extends Decoder {
val stringCodec: StringCodecBase = StringCodec
/** Decodes a single byte
*
* @return
*/
def readByte: Byte = {
buf.get
}
/** Decodes a 32-bit integer (1-5 bytes)
*
* 0XXX XXXX = 0 to 127
* 1000 XXXX b0 = 128 to 4095
* 1001 XXXX b0 = -1 to -4095
* 1010 XXXX b0 b1 = 4096 to 1048575
* 1011 XXXX b0 b1 = -4096 to -1048575
* 1100 XXXX b0 b1 b2 = 1048576 to 268435455
* 1101 XXXX b0 b1 b2 = -1048576 to -268435455
* 1110 0000 b0 b1 b2 b3 = MinInt to MaxInt
* 1111 ???? = reserved for special codings
*
*
* @return
*/
def readInt: Int = {
val b = buf.get & 0xFF
if ((b & 0x80) != 0) {
// special coding, expand sign bit
val sign = if ((b & 0x10) == 0) 1 else -1
val b0 = b & 0xF
b >> 4 match {
case 0x8 | 0x9 =>
val b1 = buf.get & 0xFF
sign * (b0 << 8 | b1)
case 0xA | 0xB =>
val b1 = buf.get & 0xFF
val b2 = buf.get & 0xFF
sign * (b0 << 16 | b1 << 8 | b2)
case 0xC | 0xD =>
val b1 = buf.get & 0xFF
val b2 = buf.get & 0xFF
val b3 = buf.get & 0xFF
sign * (b0 << 24 | b1 << 16 | b2 << 8 | b3)
case 0xE if b == 0xE0 =>
sign * readRawInt
case _ =>
throw new IllegalArgumentException("Unknown integer coding")
}
} else {
b
}
}
def readRawInt: Int = {
buf.getInt
}
/** Decodes a UTF-8 encoded string
*
* @return
*/
def readString: String = {
// read string length
val len = readInt
stringCodec.decodeFast(len, buf)
}
/** Decodes a UTF-8 encoded string whose length is already known
*
* @param len Length of the string (in bytes)
* @return
*/
def readString(len: Int): String = {
stringCodec.decodeFast(len, buf)
}
}
private[reflect] class EncoderSize(bufferProvider: BufferProvider = DefaultByteBufferProvider.provider) extends Encoder {
val stringCodec: StringCodecBase = StringCodec
@inline private def alloc(size: Int): ByteBuffer = bufferProvider.alloc(size)
/** Encodes a single byte
*
* @param b Byte to encode
* @return
*/
def writeByte(b: Byte): Encoder = {
alloc(1).put(b)
this
}
/** Encodes an integer efficiently in 1 to 5 bytes
*
* 0XXX XXXX = 0 to 127
* 1000 XXXX b0 = 128 to 4095
* 1001 XXXX b0 = -1 to -4095
* 1010 XXXX b0 b1 = 4096 to 1048575
* 1011 XXXX b0 b1 = -4096 to -1048575
* 1100 XXXX b0 b1 b2 = 1048575 to 268435455
* 1101 XXXX b0 b1 b2 = -1048575 to -268435455
* 1110 0000 b0 b1 b2 b3 = MinInt to MaxInt
* 1111 ???? = reserved for special codings
*
*
* @param i Integer to encode
*/
def writeInt(i: Int): Encoder = {
// check for a short number
if (i >= 0 && i < 128) {
alloc(1).put(i.toByte)
} else {
if (i > -268435456 && i < 268435456) {
val mask = i >>> 31 << 4
val a = Math.abs(i)
if (a < 4096) {
alloc(2).put((mask | 0x80 | (a >> 8)).toByte).put((a & 0xFF).toByte)
} else if (a < 1048576) {
alloc(3).put((mask | 0xA0 | (a >> 16)).toByte).put(((a >> 8) & 0xFF).toByte).put((a & 0xFF).toByte)
} else {
alloc(4)
.put((mask | 0xC0 | (a >> 24)).toByte)
.put(((a >> 16) & 0xFF).toByte)
.put(((a >> 8) & 0xFF).toByte)
.put((a & 0xFF).toByte)
}
} else {
alloc(5).put(0xE0.toByte).putInt(i)
}
}
this
}
/** Encodes a string using UTF8
*
* @param s String to encode
* @return
*/
def writeString(s: String): Encoder = {
writeInt(s.length)
val bb = alloc(s.length * 3)
stringCodec.encodeFast(s, bb)
this
}
/** Completes the encoding and returns the ByteBuffer
*
* @return
*/
def asByteBuffer: ByteBuffer = bufferProvider.asByteBuffer
}
================================================
FILE: izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/src/main/scala/izumi/reflect/thirdparty/internal/boopickle/Codecs.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package izumi.reflect.thirdparty.internal.boopickle
import java.nio.ByteBuffer
private[reflect] trait Decoder {
/** Decodes a single byte
*/
def readByte: Byte
/** Decodes a 32-bit integer
*/
def readInt: Int
/** Decodes a string
*/
def readString: String
/** Decodes a string whose length is already known
*
* @param len Length of the string (in bytes)
*/
def readString(len: Int): String
}
private[reflect] trait Encoder {
/** Encodes a single byte
*
* @param b Byte to encode
*/
def writeByte(b: Byte): Encoder
/** Encodes an integer
*/
def writeInt(i: Int): Encoder
/** Encodes a string
*
* @param s String to encode
*/
def writeString(s: String): Encoder
/** Completes the encoding and returns the ByteBuffer
*/
def asByteBuffer: ByteBuffer
}
================================================
FILE: izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/src/main/scala/izumi/reflect/thirdparty/internal/boopickle/CompositePicklers.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package izumi.reflect.thirdparty.internal.boopickle
import scala.collection.mutable
import scala.reflect.ClassTag
/** Encodes a class belonging to a type hierarchy. Type is identified by the index in the `picklers` sequence, so care
* must be taken to ensure picklers are added in the same order.
*/
private[reflect] class CompositePickler[A] extends Pickler[A] {
import Constants._
private var picklerClasses = IdentMap.empty
private val picklers = mutable.ArrayBuffer.empty[(Class[_], Pickler[_])]
override def pickle(obj: A)(implicit state: PickleState): Unit = {
if (obj == null) {
state.enc.writeInt(NullObject)
} else {
val clz = obj.getClass
picklerClasses(clz) match {
case None =>
throw new IllegalArgumentException(s"This CompositePickler doesn't know class '${clz.getName}'.")
case Some(idx) =>
val pickler = picklers(idx - 2)._2
state.enc.writeInt(idx - 1)
pickler.asInstanceOf[Pickler[A]].pickle(obj)
}
}
}
override def unpickle(implicit state: UnpickleState): A = {
val idx = state.dec.readInt
if (idx == NullObject) null.asInstanceOf[A]
else {
if (idx < 0 || idx > picklers.size)
throw new IllegalStateException(s"Index $idx is not defined in this CompositePickler")
picklers(idx - 1)._2.asInstanceOf[Pickler[A]].unpickle
}
}
private def addPickler[B](pickler: Pickler[B], tag: ClassTag[B]): Unit = {
val clz = tag.runtimeClass
if (picklerClasses(clz).isDefined)
throw new IllegalArgumentException(s"Cannot add same class (${clz.getName}) twice to a composite pickler")
picklerClasses = picklerClasses.updated(clz)
picklers.append((clz, pickler))
}
@noinline def addConcreteType[B <: A](implicit pickler: Pickler[B], tag: ClassTag[B]): CompositePickler[A] = {
addPickler(pickler, tag)
this
}
}
================================================
FILE: izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/src/main/scala/izumi/reflect/thirdparty/internal/boopickle/Constants.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package izumi.reflect.thirdparty.internal.boopickle
private[boopickle] object Constants {
final val NullRef = -1
final val NullObject = 0
// codes for Option
final val OptionNone: Int = 1
final val OptionSome: Int = 2
// common strings that can be used as references
val immutableInitData = Seq("null", "true", "false", "0", "1", "-1", "2", "3", "4", "5", "6", "7", "8", "9")
val identityInitData = Seq(None)
}
================================================
FILE: izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/src/main/scala/izumi/reflect/thirdparty/internal/boopickle/Default.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package izumi.reflect.thirdparty.internal.boopickle
import java.nio.ByteBuffer
import java.nio.charset.StandardCharsets
private[reflect] trait BasicImplicitPicklers extends PicklerHelper with XCompatImplicitPicklers {
implicit def booleanPickler: P[Boolean] = BasicPicklers.BooleanPickler
implicit def intPickler: P[Int] = BasicPicklers.IntPickler
implicit def stringPickler: P[String] = BasicPicklers.StringPickler
implicit def optionPickler[T: P]: P[Option[T]] = BasicPicklers.OptionPickler[T]
}
private[reflect] object PickleImpl {
@inline def apply[A](value: A)(implicit state: PickleState, p: Pickler[A]): PickleState = {
p.pickle(value)(state)
state
}
@inline def intoBytes[A](value: A)(implicit state: PickleState, p: Pickler[A]): ByteBuffer = {
apply(value).toByteBuffer
}
@inline private[reflect] def serializeIntoString[A](a: A, pickler: Pickler[A]): String = {
val pickleState = PickleState.pickleStateSpeed
val buf = PickleImpl.intoBytes(a)(pickleState, pickler)
new String(buf.array(), buf.arrayOffset(), buf.limit(), StandardCharsets.ISO_8859_1)
}
}
private[reflect] trait Base {
type Pickler[A] = _root_.izumi.reflect.thirdparty.internal.boopickle.Pickler[A]
type PickleState = _root_.izumi.reflect.thirdparty.internal.boopickle.PickleState
}
private[reflect] object NoMacro extends Base with BasicImplicitPicklers with TuplePicklers
================================================
FILE: izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/src/main/scala/izumi/reflect/thirdparty/internal/boopickle/IdentList.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package izumi.reflect.thirdparty.internal.boopickle
import scala.collection.mutable
/**
* Specialized fast and cheap to initialize identity list for unpickle state identifier refs
*/
private[reflect] abstract class IdentList {
@noinline def apply(idx: Int): AnyRef
@noinline def updated(obj: AnyRef): IdentList
}
private[reflect] object IdentList {
private[boopickle] final class Entry(val obj: AnyRef, var next: Entry)
private[boopickle] val maxSize = 32
}
private[reflect] object EmptyIdentList extends IdentList {
override def apply(idx: Int): AnyRef = throw new IndexOutOfBoundsException
override def updated(obj: AnyRef): IdentList = new IdentList1Plus(obj)
}
/**
* A fast and simple linked list implementation for identifier list
*
* @param o1 First object
*/
private[boopickle] final class IdentList1Plus(o1: AnyRef) extends IdentList {
import IdentList.Entry
var last: Entry = new Entry(o1, null)
var head: Entry = last
var switchOver = false
var size = 0
override def apply(idx: Int): AnyRef = {
// first time something is looked up, we switch to the more efficient implementation
switchOver = true
var i = 0
var e = head
while (i < idx && e != null) {
i += 1
e = e.next
}
if (e == null)
throw new IndexOutOfBoundsException
e.obj
}
override def updated(obj: AnyRef): IdentList = {
val e = new Entry(obj, null)
last.next = e
last = e
size += 1
if (switchOver || size > IdentList.maxSize)
new IdentListBig(head, size)
else
this
}
}
/**
* A more scalable implementation for an identifier list
*
* @param first First entry in a list of entries
*/
private[boopickle] final class IdentListBig(first: IdentList.Entry, size: Int) extends IdentList {
// transform the linked list into an array buffer
val b = mutable.ArrayBuffer.newBuilder[AnyRef]
b.sizeHint(size)
var e = first
while (e != null) {
b += e.obj
e = e.next
}
val entries = b.result()
override def apply(idx: Int): AnyRef = {
entries(idx)
}
override def updated(obj: AnyRef): IdentList = {
entries += obj
this
}
}
================================================
FILE: izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/src/main/scala/izumi/reflect/thirdparty/internal/boopickle/IdentMap.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package izumi.reflect.thirdparty.internal.boopickle
/**
* Specialized fast and cheap to initialize identity map for pickle state identifier map
*/
private[reflect] abstract class IdentMap {
def apply(obj: AnyRef): Option[Int]
def updated(obj: AnyRef): IdentMap
}
private[reflect] object IdentMap {
def empty: IdentMap = EmptyIdentMap
}
private[reflect] object EmptyIdentMap extends IdentMap {
override def apply(obj: AnyRef): Option[Int] = None
override def updated(obj: AnyRef): IdentMap = new IdentMap1(obj)
}
private[boopickle] final class IdentMap1(o1: AnyRef) extends IdentMap {
override def apply(obj: AnyRef): Option[Int] = {
if (ReferenceEquality.eq(obj, o1))
Some(2)
else None
}
override def updated(obj: AnyRef): IdentMap = new IdentMap2(o1, obj)
}
private[boopickle] final class IdentMap2(o1: AnyRef, o2: AnyRef) extends IdentMap {
override def apply(obj: AnyRef): Option[Int] = {
if (ReferenceEquality.eq(obj, o1))
Some(2)
else if (ReferenceEquality.eq(obj, o2))
Some(3)
else None
}
override def updated(obj: AnyRef): IdentMap = new IdentMap3Plus(o1, o2, obj)
}
private[reflect] object IdentMap3Plus {
private[boopickle] class Entry(val hash: Int, val obj: AnyRef, val idx: Int, var next: Entry)
}
private[boopickle] final class IdentMap3Plus(o1: AnyRef, o2: AnyRef, o3: AnyRef) extends IdentMap {
import IdentMap3Plus.Entry
var hashSize = 64
val maxDepth = 1
var hashTable = new Array[Entry](hashSize)
// indices 0 (not used) and 1 (for null) are reserved
var curIdx = 2
// initialize with data
updated(o1)
updated(o2)
updated(o3)
@inline private def hashIdx(hash: Int) = {
val h = scala.util.hashing.byteswap32(hash)
((h >> 16) ^ (h >> 8) ^ h) & (hashSize - 1)
}
override def apply(obj: AnyRef): Option[Int] = {
val hash = ReferenceEquality.identityHashCode(obj)
val tableIdx = hashIdx(hash)
var e = hashTable(tableIdx)
while ((e != null) && ReferenceEquality.ne(e.obj, obj)) e = e.next
if (e == null)
None
else
Some(e.idx)
}
override def updated(obj: AnyRef): IdentMap = {
val hash = ReferenceEquality.identityHashCode(obj)
val tableIdx = hashIdx(hash)
hashTable(tableIdx) = new Entry(hash, obj, curIdx, hashTable(tableIdx))
curIdx += 1
// should we switch to next gear?
if (curIdx > hashSize * maxDepth)
resize()
this
}
/**
* Resizes the underlying hash table to make indexing fast as the number of entries grows
*/
private def resize(): Unit = {
val newSize = hashSize * 4
val newTable = new Array[Entry](newSize)
// copy old entries
var i = hashSize - 1
hashSize = newSize
while (i >= 0) {
var e = hashTable(i)
while (e != null) {
val tableIdx = hashIdx(e.hash)
val n = e.next
e.next = newTable(tableIdx)
newTable(tableIdx) = e
e = n
}
i -= 1
}
hashTable = newTable
}
}
================================================
FILE: izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/src/main/scala/izumi/reflect/thirdparty/internal/boopickle/Pickler.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package izumi.reflect.thirdparty.internal.boopickle
import java.nio.ByteBuffer
import scala.collection.mutable
private[reflect] trait Pickler[A] {
def pickle(obj: A)(implicit state: PickleState): Unit
def unpickle(implicit state: UnpickleState): A
def xmap[B](ab: A => B)(ba: B => A): Pickler[B] = {
val self = this
new Pickler[B] {
override def unpickle(implicit state: UnpickleState): B = {
ab(self.unpickle(state))
}
override def pickle(obj: B)(implicit state: PickleState): Unit = {
self.pickle(ba(obj))
}
}
}
}
private[reflect] trait PicklerHelper {
protected type P[A] = Pickler[A]
/** Helper function to write pickled types
*/
protected def write[A](value: A)(implicit state: PickleState, p: P[A]): Unit = p.pickle(value)(state)
/** Helper function to unpickle a type
*/
protected def read[A](implicit state: UnpickleState, u: P[A]): A = u.unpickle
}
private[reflect] object BasicPicklers extends PicklerHelper with XCompatPicklers {
import Constants._
object BooleanPickler extends P[Boolean] {
@inline override def pickle(value: Boolean)(implicit state: PickleState): Unit = state.enc.writeByte(if (value) 1 else 0)
@inline override def unpickle(implicit state: UnpickleState): Boolean = {
state.dec.readByte match {
case 1 => true
case 0 => false
case x => throw new IllegalArgumentException(s"Invalid value $x for Boolean")
}
}
}
object IntPickler extends P[Int] {
@inline override def pickle(value: Int)(implicit state: PickleState): Unit = state.enc.writeInt(value)
@inline override def unpickle(implicit state: UnpickleState): Int = state.dec.readInt
}
object StringPickler extends P[String] {
override def pickle(s: String)(implicit state: PickleState): Unit = {
state.immutableRefFor(s) match {
case Some(idx) =>
state.enc.writeInt(-idx)
case None =>
if (s.isEmpty) {
state.enc.writeInt(0)
} else {
state.enc.writeString(s)
state.addImmutableRef(s)
}
}
}
override def unpickle(implicit state: UnpickleState): String = {
val len = state.dec.readInt
if (len < 0) {
state.immutableFor[String](-len)
} else if (len == 0) {
""
} else {
val s = state.dec.readString(len)
state.addImmutableRef(s)
s
}
}
}
def OptionPickler[T: P]: P[Option[T]] = new P[Option[T]] {
override def pickle(obj: Option[T])(implicit state: PickleState): Unit = {
obj match {
case null =>
state.enc.writeInt(NullObject)
case Some(x) =>
state.enc.writeInt(OptionSome.toInt)
write[T](x)
case None =>
// `None` is always encoded as zero
state.enc.writeInt(OptionNone.toInt)
}
}
override def unpickle(implicit state: UnpickleState): Option[T] = {
state.dec.readInt match {
case NullObject =>
null
case OptionSome =>
val o = Some(read[T])
o
case OptionNone =>
None
case _ =>
throw new IllegalArgumentException("Invalid coding for Option type")
}
}
}
}
/** Manage state for a pickling "session".
*
* @param enc Encoder instance to use
* @param dedupImmutable Set to `false` if you want to disable deduplication of immutable values (like Strings)
*/
private[reflect] final class PickleState(val enc: Encoder, dedupImmutable: Boolean = true) {
@inline def identityRefFor(obj: AnyRef): Option[Int] = None
@inline def addIdentityRef(obj: AnyRef): Unit = ()
/** Object reference for immutable pickled objects
*/
private[this] var immutableRefs: mutable.AnyRefMap[AnyRef, Int] = null
private[this] var immutableIdx = 2
@inline def immutableRefFor(obj: AnyRef): Option[Int] = {
if (obj == null)
Some(1)
else if (!dedupImmutable)
None
else if (immutableRefs != null)
immutableRefs.get(obj)
else
None
}
@inline def addImmutableRef(obj: AnyRef): Unit = {
if (dedupImmutable) {
if (immutableRefs == null)
immutableRefs = mutable.AnyRefMap.empty
immutableRefs.update(obj, immutableIdx)
immutableIdx += 1
}
}
@inline def pickle[A](value: A)(implicit p: Pickler[A]): PickleState = {
p.pickle(value)(this)
this
}
def toByteBuffer: ByteBuffer = enc.asByteBuffer
}
private[reflect] object PickleState {
/** Provides a default PickleState if none is available implicitly
*
* @return
*/
implicit def pickleStateSpeed: PickleState = new PickleState(new EncoderSize, dedupImmutable = true)
}
/** Manage state for an unpickling "session"
*
* @param dec Decoder instance to use
* @param deduplicate Set to `false` if you want to disable deduplication
* @param dedupImmutable Set to `false` if you want to disable deduplication of immutable values (like Strings)
*/
private[reflect] final class UnpickleState(val dec: Decoder, deduplicate: Boolean = true, dedupImmutable: Boolean = true) {
/** Object reference for pickled objects (use identity for equality comparison)
*
* Index 0 is not used
* Index 1 = null
* Index 2-n, references to pickled objects
*/
private[this] var identityRefs: IdentList = EmptyIdentList
@noinline def codingError(code: Int): Nothing = {
throw new IllegalArgumentException(s"Unknown object coding: $code")
}
@noinline def identityFor[A <: AnyRef](ref: Int): A = {
if (ref < 2)
null.asInstanceOf[A]
else if (!deduplicate)
throw new Exception("Deduplication is disabled, but identityFor was called.")
else
identityRefs(ref - 2).asInstanceOf[A]
}
@inline def addIdentityRef(obj: AnyRef): Unit =
if (deduplicate)
identityRefs = identityRefs.updated(obj)
/** Object reference for immutable pickled objects
*/
private[this] var immutableRefs: IdentList = EmptyIdentList
@noinline def immutableFor[A <: AnyRef](ref: Int): A = {
if (ref < 2)
null.asInstanceOf[A]
else if (dedupImmutable)
immutableRefs(ref - 2).asInstanceOf[A]
else
throw new Exception("Deduplication for immutable objects is disabled, but immutableFor was called.")
}
@inline def addImmutableRef(obj: AnyRef): Unit = {
if (dedupImmutable)
immutableRefs = immutableRefs.updated(obj)
}
@inline def unpickle[A](implicit u: Pickler[A]): A = u.unpickle(this)
}
private[reflect] object UnpickleState {
def apply(bytes: ByteBuffer) = new UnpickleState(new DecoderSize(bytes))
def apply(decoder: Decoder, deduplicate: Boolean = false, dedupImmutable: Boolean = false) =
new UnpickleState(decoder, deduplicate)
}
================================================
FILE: izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/src/main/scala/izumi/reflect/thirdparty/internal/boopickle/StringCodecBase.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package izumi.reflect.thirdparty.internal.boopickle
import java.nio.ByteBuffer
private[reflect] abstract class StringCodecFast {
/**
* String decoding function for a special 1-3 byte encoding of 16-bit char values
*
* @param len How many bytes to decode
* @param buf Buffer containing the data
* @return String with decoded data
*/
def decodeFast(len: Int, buf: ByteBuffer): String = {
if (buf.hasArray)
decodeFastArray(len, buf)
else
decodeFastBuf(len, buf)
}
/**
* String encoding function for a special 1-3 byte encoding of 16-bit char values
*
* @param s String to encode
* @return `ByteBuffer` with the encoded data
*/
def encodeFast(s: String, bb: ByteBuffer): Unit = {
if (bb.hasArray)
encodeFastArray(s, bb)
else
encodeFastBuf(s, bb)
}
def encodeFastArray(s: String, bb: ByteBuffer): Unit = {
val len = s.length()
val buf = bb.array()
var dst = bb.arrayOffset() + bb.position()
var src = 0
var c: Char = ' '
// start by encoding ASCII only
while ((src < len) && { c = s.charAt(src); c < 0x80 }) {
buf(dst) = c.toByte
src += 1
dst += 1
}
// next stage, encode also non-ASCII
while (src < len) {
c = s.charAt(src)
if (c < 0x80) {
buf(dst) = c.toByte
dst += 1
} else if (c < 0x4000) {
buf(dst) = (0x80 | (c & 0x3F)).toByte
buf(dst + 1) = (c >> 6 & 0xFF).toByte
dst += 2
} else {
buf(dst) = (0xC0 | (c & 0x3F)).toByte
buf(dst + 1) = (c >> 6 & 0xFF).toByte
buf(dst + 2) = (c >> 14).toByte
dst += 3
}
src += 1
}
(bb: java.nio.Buffer).position(dst - bb.arrayOffset())
}
def encodeFastBuf(s: String, bb: ByteBuffer): Unit = {
val len = s.length()
// worst case scenario produces 3 bytes per character
var src = 0
var c: Char = ' '
// start by encoding ASCII only
while ((src < len) && { c = s.charAt(src); c < 0x80 }) {
bb.put(c.toByte)
src += 1
}
// next stage, encode also non-ASCII
while (src < len) {
c = s.charAt(src)
if (c < 0x80) {
bb.put(c.toByte)
} else if (c < 0x4000) {
bb.put((0x80 | (c & 0x3F)).toByte)
bb.put((c >> 6 & 0xFF).toByte)
} else {
bb.put((0xC0 | (c & 0x3F)).toByte)
bb.put((c >> 6 & 0xFF).toByte)
bb.put((c >> 14).toByte)
}
src += 1
}
}
/**
* Faster decoding for array backed buffers
*/
protected def decodeFastArray(len: Int, buf: ByteBuffer): String = {
val cp = new Array[Char](len)
val src = buf.array()
var offset = buf.arrayOffset() + buf.position()
var dst = 0
while (dst < len) {
val b = src(offset)
offset += 1
if ((b & 0x80) == 0) {
cp(dst) = (b & 0x7F).toChar
} else if ((b & 0xC0) == 0x80) {
val b1 = src(offset)
offset += 1
cp(dst) = (b & 0x3F | (b1.toShort & 0xFF) << 6).toChar
} else {
val b1 = src(offset)
val b2 = src(offset + 1)
offset += 2
cp(dst) = (b & 0x3F | (b1.toShort & 0xFF) << 6 | (b2.toShort << 14)).toChar
}
dst += 1
}
(buf: java.nio.Buffer).position(offset - buf.arrayOffset())
new String(cp)
}
/**
* Decoding for normal non-array `ByteBuffer`
*/
protected def decodeFastBuf(len: Int, buf: ByteBuffer): String = {
val cp = new Array[Char](len)
var i = 0
var dst = 0
while (dst < len) {
val b = buf.get()
if ((b & 0x80) == 0) {
cp(dst) = (b & 0x7F).toChar
} else if ((b & 0xC0) == 0x80) {
val b1 = buf.get()
i += 1
cp(dst) = (b & 0x3F | (b1.toShort & 0xFF) << 6).toChar
} else {
val b1 = buf.get()
val b2 = buf.get()
i += 2
cp(dst) = (b & 0x3F | (b1.toShort & 0xFF) << 6 | (b2.toShort << 14)).toChar
}
i += 1
dst += 1
}
new String(cp)
}
}
private[reflect] abstract class StringCodecBase extends StringCodecFast {
def decodeUTF8(len: Int, buf: ByteBuffer): String
def encodeUTF8(s: String): ByteBuffer
def decodeUTF16(len: Int, buf: ByteBuffer): String
def encodeUTF16(s: String): ByteBuffer
}
================================================
FILE: izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/src/main/scala/izumi/reflect/thirdparty/internal/boopickle/TuplePicklers.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package izumi.reflect.thirdparty.internal.boopickle
private[reflect] trait TuplePicklers extends PicklerHelper {
implicit def Tuple2Pickler[T1: P, T2: P]: P[(T1, T2)] = new P[(T1, T2)] {
override def pickle(x: (T1, T2))(implicit state: PickleState): Unit = { write[T1](x._1); write[T2](x._2) }
override def unpickle(implicit state: UnpickleState): (T1, T2) = (read[T1], read[T2])
}
}
================================================
FILE: izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/src/main/scala-2.12-/izumi/reflect/thirdparty/internal/boopickle/XCompat.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package izumi.reflect.thirdparty.internal.boopickle
import izumi.reflect.thirdparty.internal.boopickle.Constants.NullRef
import scala.collection.generic.CanBuildFrom
private[reflect] trait XCompatImplicitPicklers {
this: PicklerHelper =>
implicit def mapPickler[T: P, S: P, V[_, _] <: scala.collection.Map[_, _]](
implicit cbf: CanBuildFrom[Nothing, (T, S), V[T, S]]
): P[V[T, S]] =
BasicPicklers.MapPickler[T, S, V]
implicit def iterablePickler[T: P, V[_] <: Iterable[_]](implicit cbf: CanBuildFrom[Nothing, T, V[T]]): P[V[T]] =
BasicPicklers.IterablePickler[T, V]
}
private[reflect] trait XCompatPicklers {
this: PicklerHelper =>
/**
* This pickler works on all collections that derive from Iterable[T] (Vector, Set, List, etc)
*
* @tparam T type of the values
* @tparam V type of the collection
* @return
*/
def IterablePickler[T: P, V[_] <: Iterable[_]](implicit cbf: CanBuildFrom[Nothing, T, V[T]]): P[V[T]] = new P[V[T]] {
override def pickle(iterable: V[T])(implicit state: PickleState): Unit = {
if (iterable == null) {
state.enc.writeInt(NullRef)
} else {
// encode length
state.enc.writeInt(iterable.size)
// encode contents
iterable.iterator.asInstanceOf[Iterator[T]].foreach(a => write[T](a))
}
}
override def unpickle(implicit state: UnpickleState): V[T] = {
state.dec.readInt match {
case NullRef =>
null.asInstanceOf[V[T]]
case 0 =>
// empty sequence
val res = cbf().result()
res
case len =>
val b = cbf()
b.sizeHint(len)
var i = 0
while (i < len) {
b += read[T]
i += 1
}
val res = b.result()
res
}
}
}
/**
* Maps require a specific pickler as they have two type parameters.
*
* @tparam T Type of keys
* @tparam S Type of values
* @return
*/
def MapPickler[T: P, S: P, V[_, _] <: scala.collection.Map[_, _]](
implicit cbf: CanBuildFrom[Nothing, (T, S), V[T, S]]
): P[V[T, S]] =
new P[V[T, S]] {
override def pickle(map: V[T, S])(implicit state: PickleState): Unit = {
if (map == null) {
state.enc.writeInt(NullRef)
} else {
// encode length
state.enc.writeInt(map.size)
// encode contents as a sequence
val kPickler = implicitly[P[T]]
val vPickler = implicitly[P[S]]
map.asInstanceOf[scala.collection.Map[T, S]].foreach {
kv =>
kPickler.pickle(kv._1)(state)
vPickler.pickle(kv._2)(state)
}
}
}
override def unpickle(implicit state: UnpickleState): V[T, S] = {
state.dec.readInt match {
case NullRef =>
null.asInstanceOf[V[T, S]]
case 0 =>
// empty map
val res = cbf().result()
res
case idx if idx < 0 =>
state.identityFor[V[T, S]](-idx)
case len =>
val b = cbf()
b.sizeHint(len)
val kPickler = implicitly[P[T]]
val vPickler = implicitly[P[S]]
var i = 0
while (i < len) {
b += kPickler.unpickle(state) -> vPickler.unpickle(state)
i += 1
}
val res = b.result()
res
}
}
}
}
================================================
FILE: izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/src/main/scala-2.13+/izumi/reflect/thirdparty/internal/boopickle/XCompat.scala
================================================
package izumi.reflect.thirdparty.internal.boopickle
import Constants.NullRef
import scala.collection.Factory
private[reflect] trait XCompatImplicitPicklers {
this: PicklerHelper =>
implicit def mapPickler[T: P, S: P, V[_, _] <: scala.collection.Map[_, _]](
implicit cbf: Factory[(T, S), V[T, S]]
): P[V[T, S]] = BasicPicklers.MapPickler[T, S, V]
implicit def iterablePickler[T: P, V[_] <: Iterable[_]](implicit cbf: Factory[T, V[T]]): P[V[T]] =
BasicPicklers.IterablePickler[T, V]
}
private[reflect] trait XCompatPicklers {
this: PicklerHelper =>
/**
* This pickler works on all collections that derive from Iterable[T] (Vector, Set, List, etc)
*
* @tparam T type of the values
* @tparam V type of the collection
* @return
*/
def IterablePickler[T: P, V[_] <: Iterable[_]](implicit cbf: Factory[T, V[T]]): P[V[T]] = new P[V[T]] {
override def pickle(iterable: V[T])(implicit state: PickleState): Unit = {
if (iterable == null) {
state.enc.writeInt(NullRef)
} else {
// encode length
state.enc.writeInt(iterable.size)
// encode contents
iterable.iterator.asInstanceOf[Iterator[T]].foreach(a => write[T](a))
}
}
override def unpickle(implicit state: UnpickleState): V[T] = {
state.dec.readInt match {
case NullRef =>
null.asInstanceOf[V[T]]
case 0 =>
// empty sequence
val res = cbf.newBuilder.result()
res
case len =>
val b = cbf.newBuilder
b.sizeHint(len)
var i = 0
while (i < len) {
b += read[T]
i += 1
}
val res = b.result()
res
}
}
}
/**
* Maps require a specific pickler as they have two type parameters.
*
* @tparam T Type of keys
* @tparam S Type of values
* @return
*/
def MapPickler[T: P, S: P, V[_, _] <: scala.collection.Map[_, _]](implicit cbf: Factory[(T, S), V[T, S]]): P[V[T, S]] =
new P[V[T, S]] {
override def pickle(map: V[T, S])(implicit state: PickleState): Unit = {
if (map == null) {
state.enc.writeInt(NullRef)
} else {
// encode length
state.enc.writeInt(map.size)
// encode contents as a sequence
val kPickler = implicitly[P[T]]
val vPickler = implicitly[P[S]]
map.asInstanceOf[scala.collection.Map[T, S]].foreach {
kv =>
kPickler.pickle(kv._1)(state)
vPickler.pickle(kv._2)(state)
}
}
}
override def unpickle(implicit state: UnpickleState): V[T, S] = {
state.dec.readInt match {
case NullRef =>
null.asInstanceOf[V[T, S]]
case 0 =>
// empty map
val res = cbf.newBuilder.result()
res
case idx if idx < 0 =>
state.identityFor[V[T, S]](-idx)
case len =>
val b = cbf.newBuilder
b.sizeHint(len)
val kPickler = implicitly[P[T]]
val vPickler = implicitly[P[S]]
var i = 0
while (i < len) {
b += kPickler.unpickle(state) -> vPickler.unpickle(state)
i += 1
}
val res = b.result()
res
}
}
}
}
================================================
FILE: izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/src/test/scala/izumi/reflect/.keep
================================================
================================================
FILE: keys.sh
================================================
#!/bin/bash -e
EMAIL=${EMAIL:-pshirshov@gmail.com}
SSHKEYNAME=travis-deploy-key
PASSPHRASE=$(uuidgen)
OPENSSL_KEY=`openssl rand -hex 32`
OPENSSL_IV=`openssl rand -hex 16`
SECRETS=./.secrets
GPGHOME=$SECRETS/gnupg.home
GPGTARGET=$SECRETS/gnupg
LOCALSBT=$SECRETS/local.sbt
GPGTMP=/tmp/gpginput
PUBRING=$GPGTARGET/pubring.gpg
SECRING=$GPGTARGET/secring.gpg
SSHKEY=$SECRETS/$SSHKEYNAME
echo "GPG Passphrase: $PASSPHRASE"
echo "SECRETS ENCRYPTION:"
echo "OPENSSL_KEY=$OPENSSL_KEY"
echo "OPENSSL_IV=$OPENSSL_IV"
rm -rf $GPGTARGET
rm -rf $GPGHOME
mkdir -p $GPGTARGET
mkdir -p $GPGHOME
chmod 700 $GPGHOME
cat >$GPGTMP < $SECRING
gpg --homedir $GPGHOME --batch --yes --passphrase $PASSPHRASE --pinentry-mode loopback --export > $PUBRING
#sbt shim
rm -f local.sbt
cat >$LOCALSBT < s -> scala300
case s @ "2.12" => s -> scala212
case s @ "2.11" => s -> scala211
case s @ s"2${_}" => s -> scala213
}.map {
case (s, target) =>
targetScala = target :: targetScala.filterNot(_ == target).toList
s
}.orNull
)
if (args.contains("--help")) {
println(
"launch with `./sbtgen.sc 3` to use Scala 3 in IDEA, launch with `./sbtgen.sc 2` to use Scala 2"
)
}
println(s"Scala targets: $targetScala")
Entrypoint.main(izumi_reflect, settings, Seq("-o", ".") ++ newArgs)
}
val settings = GlobalSettings(
groupId = "dev.zio",
sbtVersion = None,
scalaJsVersion = Version.VExpr("PV.scala_js_version"),
scalaNativeVersion = Version.VExpr("PV.scala_native_version"),
crossProjectVersion = Version.VExpr("PV.sbt_crossproject_version")
)
object Deps {
final val scalatest = Library("org.scalatest", "scalatest", V.scalatest, LibraryType.Auto)
final val scala_reflect = Library("org.scala-lang", "scala-reflect", Version.VExpr("scalaVersion.value"), LibraryType.Invariant)
final val scala3_compiler = Library("org.scala-lang", "scala3-compiler", Version.VExpr("scalaVersion.value"), LibraryType.AutoJvm)
final val projector = Library("org.typelevel", "kind-projector", V.kind_projector, LibraryType.Invariant)
.more(LibSetting.Raw("cross CrossVersion.full"))
}
import Deps._
object Groups {
final val izumi_reflect = Set(Group("izumi-reflect"))
}
object Targets {
def targetScala = Izumi.targetScala
private val jvmPlatform = PlatformEnv(
platform = Platform.Jvm,
language = targetScala
)
private val jsPlatform = PlatformEnv(
platform = Platform.Js,
language = targetScala.filterNot(_ == Izumi.scala211),
settings = Seq(
"coverageEnabled" := false,
"scalaJSLinkerConfig" in (SettingScope.Project, Platform.Js) := "scalaJSLinkerConfig.value.withModuleKind(ModuleKind.CommonJSModule)".raw
)
)
private val nativePlatform = PlatformEnv(
platform = Platform.Native,
language = targetScala.filterNot(_ == Izumi.scala211), // scala-native abandoned 2.11
settings = Seq(
"coverageEnabled" := false
)
)
final val crossNative = Seq(jvmPlatform, jsPlatform, nativePlatform)
}
object Projects {
object root {
final val id = ArtifactId("izumi-reflect-root")
final val plugins = Plugins(
enabled = Seq(Plugin("SbtgenVerificationPlugin")),
disabled = Seq.empty
)
final val settings = Seq()
final val sharedAggSettings = Seq(
"crossScalaVersions" := Targets.targetScala.map(_.value),
"scalaVersion" := "crossScalaVersions.value.head".raw
)
final val rootSettings = Defaults.RootOptions ++ Seq(
"crossScalaVersions" := "Nil".raw,
"organization" in SettingScope.Build := "dev.zio",
"publishTo" in SettingScope.Build :=
"""{
| if (isSnapshot.value) {
| Some(
| "central-snapshots" at "https://central.sonatype.com/repository/maven-snapshots/"
| )
| } else {
| localStaging.value
| }
|}""".stripMargin.raw,
"credentials" in SettingScope.Build ++=
"""
|{
|Seq(
| Path.userHome / ".sbt" / "secrets" / "credentials.sonatype-zio-new.properties",
| file(".") / ".secrets" / "credentials.sonatype-nexus.properties"
|)
| .filter(_.exists())
| .map(Credentials.apply)
|}""".stripMargin.raw,
"homepage" in SettingScope.Build := """Some(url("https://zio.dev"))""".raw,
"licenses" in SettingScope.Build := """Seq("Apache-2.0" -> url("http://www.apache.org/licenses/LICENSE-2.0"))""".raw,
"developers" in SettingScope.Build :=
"""List(
Developer(id = "jdegoes", name = "John De Goes", url = url("http://degoes.net"), email = "john@degoes.net"),
Developer(id = "7mind", name = "Septimal Mind", url = url("https://github.com/7mind"), email = "team@7mind.io"),
)""".raw,
"scmInfo" in SettingScope.Build := """Some(ScmInfo(url("https://github.com/zio/izumi-reflect"), "scm:git:https://github.com/zio/izumi-reflect.git"))""".raw,
"mimaBinaryIssueFilters" in SettingScope.Build ++= Seq(
// ignore deletion of old ParsedLightTypeTag* classes, they were made package private more than a year ago, they shouldn't appear in library sources anymore - or in the first place
"""ProblemFilters.exclude[MissingClassProblem]("izumi.reflect.macrortti.LightTypeTag$ParsedLightTypeTag")""".raw,
"""ProblemFilters.exclude[MissingClassProblem]("izumi.reflect.macrortti.LightTypeTag$ParsedLightTypeTag110")""".raw,
"""ProblemFilters.exclude[MissingClassProblem]("izumi.reflect.macrortti.LightTypeTag$ParsedLightTypeTag210")""".raw,
"""ProblemFilters.exclude[MissingClassProblem]("izumi.reflect.macrortti.LightTypeTag$ParsedLightTypeTagM8")""".raw,
// dotty-only ProductX case class inheritance breakage
"""ProblemFilters.exclude[IncompatibleResultTypeProblem]("izumi.reflect.macrortti.LightTypeTagRef#FullReference._1")""".raw,
// new inherited methods added (2.11 problem only?)
"""ProblemFilters.exclude[InheritedNewAbstractMethodProblem]("izumi.reflect.macrortti.LightTypeTagRef*")""".raw,
// new methods added
"""ProblemFilters.exclude[ReversedMissingMethodProblem]("izumi.reflect.macrortti.LTTRenderables.r_LambdaParameterName")""".raw,
"""ProblemFilters.exclude[ReversedMissingMethodProblem]("izumi.reflect.macrortti.LightTypeTag.binaryFormatVersion")""".raw,
"""ProblemFilters.exclude[ReversedMissingMethodProblem]("izumi.reflect.macrortti.LightTypeTagRef.repr")""".raw,
"""ProblemFilters.exclude[ReversedMissingMethodProblem]("izumi.reflect.macrortti.LTTRenderables.r_Wildcard")""".raw,
"""ProblemFilters.exclude[ReversedMissingMethodProblem]("izumi.reflect.macrortti.LTTRenderables.prefixSplitter")""".raw,
"""ProblemFilters.exclude[ReversedMissingMethodProblem]("izumi.reflect.macrortti.LightTypeTagRef.longNameWithPrefix")""".raw,
"""ProblemFilters.exclude[ReversedMissingMethodProblem]("izumi.reflect.macrortti.LightTypeTagRef.longNameInternalSymbol")""".raw,
"""ProblemFilters.exclude[ReversedMissingMethodProblem]("izumi.reflect.macrortti.LightTypeTagRef#AppliedNamedReference.symName")""".raw,
"""ProblemFilters.exclude[ReversedMissingMethodProblem]("izumi.reflect.macrortti.LightTypeTagRef#AppliedNamedReference.prefix")""".raw,
"""ProblemFilters.exclude[ReversedMissingMethodProblem]("izumi.reflect.macrortti.LightTypeTagRef.scalaStyledName")""".raw,
"""ProblemFilters.exclude[ReversedMissingMethodProblem]("izumi.reflect.macrortti.LightTypeTagRef.scalaStyledRepr")""".raw,
"""ProblemFilters.exclude[ReversedMissingMethodProblem]("izumi.reflect.AnyTag.=:=")""".raw,
"""ProblemFilters.exclude[ReversedMissingMethodProblem]("izumi.reflect.AnyTag.<:<")""".raw,
// compile-time only
"""ProblemFilters.exclude[Problem]("izumi.reflect.TagMacro.*")""".raw,
"""ProblemFilters.exclude[Problem]("izumi.reflect.macrortti.LightTypeTagImpl.*")""".raw,
"""ProblemFilters.exclude[Problem]("izumi.reflect.macrortti.LightTypeTagImpl#*")""".raw,
"""ProblemFilters.exclude[Problem]("izumi.reflect.dottyreflection.*")""".raw,
// private packages
"""ProblemFilters.exclude[Problem]("izumi.reflect.thirdparty.*")""".raw,
"""ProblemFilters.exclude[Problem]("izumi.reflect.internal.*")""".raw,
"""ProblemFilters.exclude[Problem]("izumi.reflect.ReflectionUtil*")""".raw,
// private methods
"""ProblemFilters.exclude[DirectMissingMethodProblem]("izumi.reflect.macrortti.LightTypeTagImpl.norm")""".raw,
"""ProblemFilters.exclude[DirectMissingMethodProblem]("izumi.reflect.macrortti.LightTypeTagImpl.izumi$reflect$macrortti$LightTypeTagImpl$$*")""".raw,
// private types
"""ProblemFilters.exclude[DirectMissingMethodProblem]("izumi.reflect.macrortti.LightTypeTagInheritance.CtxExt")""".raw,
"""ProblemFilters.exclude[MissingFieldProblem]("izumi.reflect.macrortti.LightTypeTagInheritance.CtxExt")""".raw,
"""ProblemFilters.exclude[FinalClassProblem]("izumi.reflect.macrortti.LightTypeTagInheritance$CtxExt")""".raw,
"""ProblemFilters.exclude[MissingTypesProblem] ("izumi.reflect.macrortti.LightTypeTagInheritance$Ctx*")""".raw,
"""ProblemFilters.exclude[Problem] ("izumi.reflect.macrortti.LightTypeTagInheritance#Ctx*")""".raw,
"""ProblemFilters.exclude[Problem] ("izumi.reflect.macrortti.LightTypeTagUnpacker*")""".raw
),
"mimaFailOnProblem" in SettingScope.Build := true,
"mimaFailOnNoPrevious" in SettingScope.Build := false,
"useGpg" in SettingScope.Build := false,
// scala-steward workaround
// add sbtgen version to sbt build to allow scala-steward to find it and update it in .sc files
// https://github.com/scala-steward-org/scala-steward/issues/696#issuecomment-545800968
"libraryDependencies" += s""""io.7mind.izumi.sbt" % "sbtgen_2.13" % "${Version.SbtGen.value}" % Provided""".raw
)
final val sharedSettings =
Defaults.CrossScalaPlusSources ++
Defaults.CrossScalaRangeSources ++
Seq(
"test" in Platform.Native := "{}".raw,
"test" in (SettingScope.Test, Platform.Native) := "{}".raw,
"sources" in SettingScope.Raw("Compile / doc") := Seq(
SettingKey(Some(scala300), None) := Seq.empty[String],
SettingKey.Default := "(Compile / doc / sources).value".raw
),
"testOptions" in SettingScope.Test += """Tests.Argument("-oDF")""".raw,
// "testOptions" in (SettingScope.Test, Platform.Jvm) ++= s"""Seq(Tests.Argument("-u"), Tests.Argument(s"$${target.value}/junit-xml-$${scalaVersion.value}"))""".raw,
"scalacOptions" ++= {
val removedOpts = Set[Const](
"-P:kind-projector:underscore-placeholders",
"-Vimplicits",
"-Xsource:3", // FIXME return after dropping 2.11 (NB: may cause bincompat issues)
"-Xsource:3-cross" // FIXME return after dropping 2.11 (NB: may cause bincompat issues)
)
val addedOpts = Seq[Const](
"-Wconf:msg=nowarn:silent"
)
Seq(
SettingKey(Some(scala211), None) := Const.EmptySeq,
SettingKey(Some(scala212), None) := Defaults.Scala212Options.filterNot(removedOpts) ++ addedOpts,
SettingKey(Some(scala213), None) := Defaults.Scala213Options.filterNot(removedOpts) ++ addedOpts,
SettingKey.Default := Seq(
"-Ykind-projector",
"-no-indent",
"-language:implicitConversions"
)
)
},
"scalacOptions" -= "-Wconf:any:error",
"mimaPreviousArtifacts" := Seq(
SettingKey(Some(scala300), None) := """Set(organization.value %% name.value % "2.2.5", organization.value %% name.value % "2.1.0")""".raw,
SettingKey.Default := """Set(organization.value %% name.value % "2.2.5", organization.value %% name.value % "2.1.0", organization.value %% name.value % "1.0.0")""".raw
),
"scalacOptions" ++= Seq(
SettingKey(Some(scala213), None) := Seq(
// workaround for https://github.com/scala/bug/issues/12103
"-Xlint:-implicit-recursion"
),
SettingKey.Default := Const.EmptySeq
),
"scalacOptions" ++= {
val inlineOpts = Seq(
"-opt:l:inline",
"-opt-inline-from:izumi.reflect.**"
)
Seq(
SettingKey(Some(scala212), Some(true)) := inlineOpts,
SettingKey(Some(scala213), Some(true)) := inlineOpts,
SettingKey.Default := Const.EmptySeq
)
},
// For compatibility with Java 9+ module system;
// without Automatic-Module-Name, the module name is derived from the jar file which is invalid because of the scalaVersion suffix.
"packageOptions" in SettingScope.Raw("Compile / packageBin") +=
s"""Package.ManifestAttributes("Automatic-Module-Name" -> s"$${organization.value.replaceAll("-",".")}.$${moduleName.value.replaceAll("-",".")}")""".raw
)
}
object izumi_reflect_aggregate {
final val id = ArtifactId("izumi-reflect-aggregate")
final val basePath = Seq("izumi-reflect")
final val izumi_reflect = ArtifactId("izumi-reflect")
final val thirdpartyBoopickleShaded = ArtifactId("izumi-reflect-thirdparty-boopickle-shaded")
}
}
final lazy val izumi_reflect_aggregate = Aggregate(
name = Projects.izumi_reflect_aggregate.id,
artifacts = Seq(
Artifact(
name = Projects.izumi_reflect_aggregate.thirdpartyBoopickleShaded,
libs = Seq.empty,
depends = Seq.empty,
settings = Seq(
SettingDef.RawSettingDef(
"""Compile / scalacOptions --= Seq("-Ywarn-value-discard","-Ywarn-unused:_", "-Wvalue-discard", "-Wunused:_")""",
FullSettingScope(SettingScope.Compile, Platform.All)
)
)
),
Artifact(
name = Projects.izumi_reflect_aggregate.izumi_reflect,
libs = Seq.empty,
depends = Seq(
Projects.izumi_reflect_aggregate.thirdpartyBoopickleShaded
)
)
),
pathPrefix = Projects.izumi_reflect_aggregate.basePath,
groups = Groups.izumi_reflect,
defaultPlatforms = Targets.crossNative,
enableProjectSharedAggSettings = false,
settings = Seq(
"crossScalaVersions" := "Nil".raw
)
)
final lazy val izumi_reflect: Project = Project(
name = Projects.root.id,
aggregates = Seq(
izumi_reflect_aggregate
),
topLevelSettings = Projects.root.settings,
sharedSettings = Projects.root.sharedSettings,
sharedAggSettings = Projects.root.sharedAggSettings,
rootSettings = Projects.root.rootSettings,
imports = Seq(
Import("com.typesafe.tools.mima.core._")
),
globalLibs = Seq(
ScopedLibrary(projector, FullDependencyScope(Scope.Compile, Platform.All).scalaVersion(ScalaVersionScope.AllScala2), compilerPlugin = true),
scala_reflect in Scope.Provided.all.scalaVersion(ScalaVersionScope.AllScala2),
scala3_compiler in Scope.Provided.all.scalaVersion(ScalaVersionScope.AllScala3),
scalatest in Scope.Test.all
),
rootPlugins = Projects.root.plugins,
globalPlugins = Plugins(),
pluginConflictRules = Map.empty,
appendPlugins = Defaults.SbtGenPlugins ++ Seq(
SbtPlugin("com.github.sbt", "sbt-pgp", PV.sbt_pgp),
SbtPlugin("org.scoverage", "sbt-scoverage", PV.sbt_scoverage),
SbtPlugin("com.typesafe", "sbt-mima-plugin", PV.sbt_mima_version),
SbtPlugin("dev.zio", "zio-sbt-website", PV.zio_sbt_website)
)
)
}
================================================
FILE: project/Settings.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
import sbt.settingKey
object DocKeys {
lazy val prefix = settingKey[String]("")
}
================================================
FILE: project/Versions.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
object V {
val kind_projector = "0.13.3"
val scalatest = "3.2.19"
}
================================================
FILE: project/build.properties
================================================
#
# Copyright 2019-2020 Septimal Mind Ltd
# Copyright 2020 John A. De Goes and the ZIO Contributors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# You may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
#
sbt.version=1.11.2
================================================
FILE: project/plugins.sbt
================================================
// DO NOT EDIT THIS FILE
// IT IS AUTOGENERATED BY `sbtgen.sc` SCRIPT
// ALL CHANGES WILL BE LOST
// https://www.scala-js.org/
addSbtPlugin("org.scala-js" % "sbt-scalajs" % PV.scala_js_version)
// https://github.com/portable-scala/sbt-crossproject
addSbtPlugin("org.portable-scala" % "sbt-scalajs-crossproject" % PV.sbt_crossproject_version)
// https://scalacenter.github.io/scalajs-bundler/
addSbtPlugin("ch.epfl.scala" % "sbt-scalajs-bundler" % "0.21.1")
// https://github.com/scala-js/jsdependencies
addSbtPlugin("org.scala-js" % "sbt-jsdependencies" % "1.0.2")
addSbtPlugin("org.portable-scala" % "sbt-scala-native-crossproject" % PV.sbt_crossproject_version)
addSbtPlugin("org.scala-native" % "sbt-scala-native" % PV.scala_native_version)
////////////////////////////////////////////////////////////////////////////////
addSbtPlugin("io.7mind.izumi.sbt" % "sbt-izumi" % "0.0.107")
addSbtPlugin("com.github.sbt" % "sbt-pgp" % PV.sbt_pgp)
addSbtPlugin("org.scoverage" % "sbt-scoverage" % PV.sbt_scoverage)
addSbtPlugin("com.typesafe" % "sbt-mima-plugin" % PV.sbt_mima_version)
addSbtPlugin("dev.zio" % "zio-sbt-website" % PV.zio_sbt_website)
// Ignore scala-xml version conflict between scoverage where `coursier` requires scala-xml v2
// and scoverage requires scala-xml v1 on Scala 2.12,
// introduced when updating scoverage from 1.9.3 to 2.0.5
libraryDependencySchemes += "org.scala-lang.modules" %% "scala-xml" % VersionScheme.Always
================================================
FILE: project/project/PluginVersions.scala
================================================
/*
* Copyright 2019-2020 Septimal Mind Ltd
* Copyright 2020 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
object PV {
val sbt_scoverage = "2.3.1"
val sbt_pgp = "2.3.1"
val sbt_mima_version = "1.1.0"
// last 2.11 version is 1.12.0, so we excluded 2.11 from JS builds, see nscplugin on maven central
val scala_js_version = "1.17.0"
// last 2.11 version is 0.4.9, so we excluded 2.11 from Native builds, see nscplugin on maven central
val scala_native_version = "0.5.7"
val sbt_crossproject_version = "1.3.2"
val zio_sbt_website = "0.4.0-alpha.31"
}
================================================
FILE: sbtgen.sc
================================================
#!/bin/sh
cs launch com.lihaoyi:ammonite_2.13.13:3.0.0-M1 --fork -M ammonite.Main -- sbtgen.sc $*
exit
!#
import $file.project.Deps, Deps._
@main
def entrypoint(args: String*) = Izumi.entrypoint(args)
================================================
FILE: version.sbt
================================================
ThisBuild / version := "3.0.10-SNAPSHOT"
