Un modo per accedere al tipo di una dichiarazione di Scala Opzione in fase di runtime utilizzando la riflessione?

Question

Quindi, ho una classe Scala che assomiglia a questo:

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

e sto affrontando un problema in cui ho un valore String e voglio costringere in che l'opzione [Int] in fase di esecuzione utilizzando la riflessione . Così, in un altro pezzo di codice (che non sa nulla TestClass) ho qualche codice come questo:

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) 
} 

Per fare questo, ho bisogno di sapere che il campo è una possibilità e che il parametro tipo di opzione è Int.

Quali sono le mie opzioni per capire che il tipo di 'valore' è Opzione [Int] in fase di esecuzione (ad esempio utilizzando la riflessione)?

Ho visto problemi simili risolti annotando il campo, ad es. @OptionType (Int.class). Preferirei una soluzione che non richiedesse annotazioni sul target di riflessione, se possibile.

Answer 1

E 'abbastanza streightforward utilizzando Java 1.5 riflessione API:

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

Il problema è che JVM implementa i farmaci generici tramite la cancellazione dei tipi. Quindi è impossibile scoprire attraverso il riflesso che il tipo di value è Option[Int] perché in realtà non lo è: è solo Option!

In 2,8 si dovrebbe essere in grado di utilizzare Manifests come questo:

Generics

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

Answer 4

A livello di bytecode, Java non ha. I generici sono implementati con il polimorfismo, quindi una volta compilato il codice sorgente (in questo caso Scala), i tipi generici scompaiono (questo è chiamato type erasure). Ciò non rende possibile raccogliere informazioni di tipo runtime generico tramite riflessione.

Un possibile - sebbene poco sporco - soluzione è ottenere il tipo di runtime di una proprietà che si conosce ha lo stesso tipo del parametro generico. Per le istanze di opzione possiamo utilizzare get membro

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 
    } 
}