Gibt es eine Möglichkeit, auf den Typ einer Scala Option Deklaration zur Laufzeit mit Reflektion zuzugreifen?

Question

So habe ich eine Scala-Klasse, die wie folgt aussieht:

class TestClass { 
    var value: Option[Int] = None 
} 

und ich bin der Bekämpfung ein Problem, wo ich einen String-Wert haben, und ich will es in diese Option [Int] zur Laufzeit zwingen, mithilfe von Reflektion . Also, in einem anderen Teil des Codes (das weiß nichts von Testclass) ich so einen Code haben:

def setField[A <: Object](target: A, fieldName: String, value: String) { 
    val field = target.getClass.getDeclaredField(fieldName) 
    val coercedValue = ???; // How do I figure out that this needs to be Option[Int] ? 
    field.set(target, coercedValue) 
} 

Um dies zu tun, ich muss wissen, dass das Feld eine Option ist und dass der Typ-Parameter der Option ist Int.

Welche Optionen habe ich, um herauszufinden, dass der Typ von 'Wert' zur Laufzeit Option (Int) ist (d. H. Mit Reflektion)?

Ich habe ähnliche Probleme durch Annotation des Feldes, z. @OptionType (Int.Klasse). Ich würde eine Lösung bevorzugen, die nach Möglichkeit keine Anmerkungen zum Reflexionsziel erfordert.

Answer 1

Es ist ziemlich verwenden streightforward Java 1.5 Reflection-API verwenden:

def isIntOption(clasz: Class[_], propertyName: String) = { 
    var result = 
    for { 
     method <- cls.getMethods 
     if method.getName==propertyName+"_$eq" 
     param <- method.getGenericParameterTypes.toList.asInstanceOf[List[ParameterizedType]] 
    } yield 
     param.getActualTypeArguments.toList == List(classOf[Integer]) 
     && param.getRawType == classOf[Option[_]] 
    if (result.length != 1) 
    throw new Exception(); 
    else 
    result(0) 
} 

Answer 2

class TestClass { 
    var value: Option[Int] = None 
// ... 

    def doSomething { 
    value match { 
     case Some(i) => // i is an Int here 
     case None => 
     // No other possibilities 
    } 
    } 
} 

Answer 3

Das Problem ist, dass JVM Generics durch Typ löschen implementiert. Es ist also unmöglich durch Reflektion zu entdecken, dass der Typ valueOption[Int] ist, weil es zur Laufzeit nicht wirklich ist: es ist nur Option!

In 2.8 sollten Sie in der Lage sein Manifests wie folgt zu verwenden:

var value: Option[Int] = None 
val valueManifest = implicitly[scala.reflect.Manifest[Option[Int]]] 
valueManifest.typeArguments // returns Some(List(Int)) 

Answer 4

auf Byte-Code-Ebene hat sich Java nicht bekam Generics. Generics werden mit Polymorphismus implementiert. Sobald Ihr Quellcode (in diesem Fall Scala) kompiliert wurde, verschwinden generische Typen (dies wird type erasure genannt). Dies macht es nicht möglich, generische Laufzeittypinformationen durch Reflektion zu sammeln.

Eine mögliche --wohl kleine schmutzige - Problemumgehung ist es, den Laufzeittyp einer Eigenschaft zu erhalten, von der Sie wissen, dass sie denselben Typ wie der Parameter Generic hat. Für Option Instanzen können wir get Mitglied

object Test { 

    def main(args : Array[String]) : Unit = { 
    var option: Option[_]= None 
    println(getType(option).getName) 
    option = Some(1) 
    println(getType(option).getName) 

    } 

    def getType[_](option:Option[_]):Class[_]= { 
     if (option.isEmpty) classOf[Nothing] else (option.get.asInstanceOf[AnyRef]).getClass 
    } 
}