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