Avoid use of Java Reflection (restructure part 5) #870
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,5 +1,4 @@ | ||
|
|
||
| import scala.reflect.ClassTag | ||
|
|
||
| package object scalan { | ||
|
|
||
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,70 @@ | ||
| package scalan.reflection | ||
|
|
||
| import scala.collection.compat.immutable.ArraySeq | ||
| import scala.collection.mutable | ||
| import scala.collection.immutable | ||
|
|
||
| /** Reflection metadata and global dictionaries to access it. */ | ||
| object CommonReflection { | ||
| /** Descriptors of classes. */ | ||
| val classes = mutable.HashMap.empty[Class[_], SRClass[_]] | ||
|
|
||
| /** Registers a class entry in the map of classes. | ||
| * | ||
| * @tparam T the type of the class to be registered | ||
| * @param clazz the class to be registered | ||
| * @param constructors the constructors of the class | ||
| * @param fields the fields of the class | ||
| * @param methods the methods of the class (represented as a map of method names and argument types to the corresponding RMethod instances) | ||
| */ | ||
| def registerClassEntry[T](clazz: Class[T], | ||
| constructors: Seq[SRConstructor[_]] = ArraySeq.empty, | ||
| fields: Map[String, SRField] = Map.empty, | ||
| methods: Map[(String, Seq[Class[_]]), RMethod] = Map.empty): Unit = classes.synchronized { | ||
| classes.put(clazz, new SRClass(clazz, constructors, fields, methods)) | ||
| } | ||
|
|
||
| registerClassEntry(classOf[Boolean]) | ||
|
|
||
| registerClassEntry(classOf[Byte]) | ||
|
|
||
| registerClassEntry(classOf[Short]) | ||
|
|
||
| registerClassEntry(classOf[Int]) | ||
|
|
||
| registerClassEntry(classOf[Long]) | ||
|
|
||
| registerClassEntry(classOf[Product2[_, _]]) | ||
|
|
||
| registerClassEntry(classOf[immutable.$colon$colon[_]], | ||
| constructors = Array( | ||
| mkConstructor(Array(classOf[java.lang.Object], classOf[immutable.List[_]])) { args => | ||
| new immutable.$colon$colon(args(0).asInstanceOf[java.lang.Object], args(1).asInstanceOf[immutable.List[_]]) | ||
| } | ||
| ) | ||
| ) | ||
|
|
||
| { val clazz = classOf[scala.Option[_]] | ||
| registerClassEntry(clazz, | ||
| methods = Map( | ||
| mkMethod(clazz, "filter", Array(classOf[scala.Function1[_,_]])) { (obj, args) => | ||
| obj.asInstanceOf[Option[Any]].filter(args(0).asInstanceOf[Any => Boolean]) | ||
| }, | ||
| mkMethod(clazz, "map", Array(classOf[scala.Function1[_,_]])) { (obj, args) => | ||
| obj.asInstanceOf[Option[Any]].map(args(0).asInstanceOf[Any => Any]) | ||
| } | ||
| ) | ||
| ) | ||
| } | ||
|
|
||
| { val clazz = classOf[scala.Some[_]] | ||
| registerClassEntry(clazz, | ||
| constructors = Array( | ||
| mkConstructor(Array(classOf[java.lang.Object])) { args => | ||
| new scala.Some(args(0).asInstanceOf[java.lang.Object]) | ||
| } | ||
| ) | ||
| ) | ||
| } | ||
|
|
||
| } |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,159 @@ | ||
| package scalan.reflection | ||
|
|
||
| import debox.cfor | ||
| import scalan.reflection.memoize | ||
|
|
||
| import java.lang.reflect.{Field, Constructor, Method} | ||
| import scala.collection.concurrent.TrieMap | ||
| import scala.collection.mutable | ||
|
|
||
| /** | ||
| * A class that represents a Java class of type `T`. | ||
| * | ||
| * @constructor creates a new instance of `JRClass` with the given value. | ||
| * @param value the Java class of type `T`. | ||
| */ | ||
| class JRClass[T](val value: Class[T]) extends RClass[T] { | ||
|
|
||
| /** A mutable map that stores the fields of this class. */ | ||
| val fields = TrieMap.empty[String, RField] | ||
|
|
||
| override def getField(name: String): RField = | ||
| memoize(fields)(name, JRField(value.getField(name))) | ||
|
|
||
| /** A mutable map that stores the methods of this class. */ | ||
| val methods = TrieMap.empty[(String, Seq[Class[_]]), RMethod] | ||
|
|
||
| override def getMethod(name: String, parameterTypes: Class[_]*): RMethod = { | ||
| memoize(methods)((name, parameterTypes), JRMethod(this, value.getMethod(name, parameterTypes:_*))) | ||
| } | ||
|
|
||
| override def getSimpleName: String = value.getSimpleName | ||
| override def getName: String = value.getName | ||
|
|
||
| /** A sequence that stores the constructors of this class. */ | ||
| var constructors: Seq[RConstructor[_]] = _ | ||
|
|
||
| override def getConstructors(): Seq[RConstructor[_]] = { | ||
| if (constructors == null) { | ||
| synchronized { | ||
| if (constructors == null) { | ||
| val cs = value.getConstructors.asInstanceOf[Array[Constructor[Any]]] | ||
| val buf = mutable.ArrayBuilder.make[RConstructor[Any]] | ||
| cfor(0)(_ < cs.length, _ + 1) { i => | ||
| val c = cs(i) | ||
| buf += JRConstructor[Any](i, c) | ||
| } | ||
| constructors = buf.result().asInstanceOf[Array[RConstructor[_]]] | ||
| } | ||
| } | ||
| } | ||
| constructors | ||
| } | ||
|
|
||
| /** Helper method that returns a sequence of `JRConstructor` objects that were at least | ||
|
There was a problem hiding this comment. "a sequence of" seems to be excessive here as well |
||
| * once used at runtime. | ||
| */ | ||
| def getUsedConstructors(): Seq[JRConstructor[_]] = | ||
| getConstructors().collect { case c: JRConstructor[_] if c.wasUsed => c } | ||
|
|
||
| override def isPrimitive(): Boolean = value.isPrimitive | ||
|
|
||
| override def getSuperclass(): RClass[_ >: T] = RClass(value.getSuperclass) | ||
|
|
||
| override def isAssignableFrom(cls: Class[_]): Boolean = value.isAssignableFrom(cls) | ||
|
|
||
| override def getDeclaredMethods(): Array[RMethod] = value.getDeclaredMethods.map(JRMethod(this, _)) | ||
|
|
||
| override def equals(other: Any): Boolean = (this eq other.asInstanceOf[AnyRef]) || (other match { | ||
| case that: JRClass[_] => | ||
| val eq = value == that.value | ||
| if (!eq) | ||
| assert(this.getName != that.getName) // sanity check | ||
| eq | ||
| case _ => false | ||
| }) | ||
|
|
||
| override def hashCode(): Int = value.hashCode() | ||
|
|
||
| override def toString: String = s"JRClass(${value.getName})" | ||
| } | ||
|
|
||
|
|
||
| /** Implements [[RField]] using Java reflection. | ||
| * | ||
| * @param value The [[java.lang.reflect.Field]] object to wrap. | ||
| */ | ||
| class JRField private (val value: Field) extends RField { | ||
| override def getType: Class[_] = value.getType | ||
|
|
||
| override def equals(other: Any): Boolean = (this eq other.asInstanceOf[AnyRef]) || (other match { | ||
| case that: JRField => value == that.value | ||
| case _ => false | ||
| }) | ||
| override def hashCode(): Int = value.hashCode() | ||
| override def toString: String = s"JRField($value)" | ||
| } | ||
| object JRField { | ||
| private[reflection] def apply(field: Field): RField = new JRField(field) | ||
| } | ||
|
|
||
| /** Implements [[RConstructor]] using Java reflection. | ||
| * | ||
| * @tparam T The type of the class that declares this constructor. | ||
| * @param index The index of the constructor in the sequence of all constructors of the class. | ||
| * @param value The [[java.lang.reflect.Constructor]] to be wrapped. | ||
| */ | ||
| class JRConstructor[T] private (val index: Int, val value: Constructor[T]) extends RConstructor[T] { | ||
| @volatile var wasUsed: Boolean = false | ||
| override def newInstance(initargs: AnyRef*): T = { | ||
| wasUsed = true | ||
| value.newInstance(initargs:_*) | ||
| } | ||
| override def getParameterTypes(): Array[Class[_]] = { | ||
| wasUsed = true | ||
| value.getParameterTypes | ||
| } | ||
|
|
||
| override def equals(other: Any): Boolean = (this eq other.asInstanceOf[AnyRef]) || (other match { | ||
| case that: JRConstructor[_] => value == that.value | ||
| case _ => false | ||
| }) | ||
| override def hashCode(): Int = value.hashCode() | ||
| override def toString: String = s"JRConstructor($index, $value)" | ||
| } | ||
| object JRConstructor { | ||
| private[reflection] def apply[T](index: Int, value: Constructor[T]): RConstructor[T] = new JRConstructor[T](index, value) | ||
| } | ||
|
|
||
| /** | ||
| * Implements [[RMethod]] using Java reflection. | ||
| * | ||
| * @param declaringClass The JRClass that declares this method. | ||
| * @param value The [[java.lang.reflect.Method]] instance that this JRMethod represents. | ||
| */ | ||
| class JRMethod private (declarigClass: JRClass[_], val value: Method) extends RMethod { | ||
|
|
||
| override def invoke(obj: Any, args: AnyRef*): AnyRef = { | ||
| val name = value.getName | ||
| val parameterTypes: Seq[Class[_]] = value.getParameterTypes | ||
| memoize(declarigClass.methods)((name, parameterTypes), this) | ||
| value.invoke(obj, args:_*) | ||
| } | ||
|
|
||
| override def getName: String = value.getName | ||
|
|
||
| override def getDeclaringClass(): Class[_] = value.getDeclaringClass | ||
|
|
||
| override def getParameterTypes(): Seq[Class[_]] = value.getParameterTypes | ||
|
|
||
| override def equals(other: Any): Boolean = (this eq other.asInstanceOf[AnyRef]) || (other match { | ||
| case that: JRMethod => value == that.value | ||
| case _ => false | ||
| }) | ||
|
|
||
| override def hashCode(): Int = value.hashCode() | ||
| override def toString: String = s"JRMethod($value)" | ||
| } | ||
| object JRMethod { | ||
| private[reflection] def apply(clazz: JRClass[_], value: Method): RMethod = new JRMethod(clazz, value) | ||
| } | ||
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Just "Constructors of this class" ? see https://docs.scala-lang.org/style/scaladoc.html#general-style
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
fixed