Aucun TypeTag disponible pour la classe de cas Type

J'ai pu trouver une solution. Comme je n'ai pas pu obtenir classTag et typeTag , j'ai modifié la fonction toMap comme suit:

//Converting an Object into a Map
val r = currentMirror.reflect(input)
val mapValues = r.symbol.typeSignature.members.toStream
  .collect{case s : TermSymbol if !s.isMethod => r.reflectField(s)}
  .map(r => r.symbol.name.toString.trim -> r.get)
  .toMap

val mapTypes = r.symbol.typeSignature.members.toStream
  .collect{case s : TermSymbol if !s.isMethod => r.reflectField(s)}
  .map(r => r.symbol.name.toString.trim -> r.symbol.typeSignature)
  .toMap

val mapTypesSymbols = r.symbol.typeSignature.members.toStream
  .collect{case s : TermSymbol if !s.isMethod => r.reflectField(s)}
  .map(r => r.symbol.name.toString.trim -> r.symbol.typeSignature.typeSymbol)
  .toMap

val nameType = mapTypes("name")
val nameTypeSymbols =  mapTypesSymbols("name")
val nameValue =  mapValues("name")

// Converting Name into a map
    val r2 = currentMirror.reflect(nameValue)
    val nameAsMapValues = r2.symbol.typeSignature.members.toStream
      .collect{case s : TermSymbol if !s.isMethod => r2.reflectField(s)}
      .map(r2 => r2.symbol.name.toString.trim -> r2.get)
      .toMap

type nameT = nameType.type

val obj = fromMap2[nameT](nameAsMapValues, nameTypeSymbols, nameType)

Alors maintenant, je dois passer le type et le symbole de T. Je peux obtenir ces deux valeurs comme suit:

def fromMap2[T : ClassTag ](m: Map[String,_], mSymbol: Symbol, mType :Type): Any = {
    val rm = runtimeMirror(classTag[T].runtimeClass.getClassLoader)
    val classTest = mSymbol.asClass
    val classMirror = rm.reflectClass(classTest)
    val constructor = mType.decl(termNames.CONSTRUCTOR).asMethod
    val constructorMirror = classMirror.reflectConstructor(constructor)

    val constructorArgs = constructor.paramLists.flatten.map( (param: Symbol) => {
      val paramName = param.name.toString
      if(param.typeSignature <:< typeOf[Option[Any]])
        m.get(paramName)
      else
        m.get(paramName).getOrElse(throw new IllegalArgumentException("Map is missing required parameter named " + paramName))
    })

    constructorMirror(constructorArgs:_*).asInstanceOf[T]

  }

Même si cela fonctionne, je pense que c'est très anti-pattern. Je vais donc laisser la question ouverte au cas où quelqu'un pourrait indiquer des moyens de l'améliorer.

Je ne suis pas tout à fait sûr d'interpréter correctement votre question, mais d'après ce que j'ai compris, cela peut être résolu assez bien et taper en toute sécurité via informe. Pour commencer, vous souhaitez convertir votre Document en Carte . shapeless peut le faire directement pour vous avec l'une des classes de types dans le dossier ops . Si nous regroupons cela dans une fonction, avec des machines pour tout rassembler, nous obtenons quelque chose comme:

val doc = MapToObject[Documents].from(m)
println(doc) //Some(Documents(12,Name(Roger,Rabbit),ABCD))

qui génère

trait MapToObject[A]{
  def from[Repr <: HList](m: Map[_,_])(
    implicit
    gen: LabelledGeneric.Aux[A,Repr],
    fromMap: ops.maps.FromMap[Repr]
  ): Option[A] = fromMap(m).map(gen.from)
}

object MapToObject{
  def apply[A](
    implicit gen: LabelledGeneric[A]
  ): MapToObject[A] = new MapToObject[A]{}
}

Aller dans l'autre sens est un peu plus compliqué. Il existe une classe de types ops.maps.FromMap . Cependant, nous voulons pouvoir spécifier le paramètre de type, puis laisser le compilateur vérifier toujours que la représentation générique est une HList , pour correspondre à la signature de FromMap . Puisque les types dépendants ne fonctionnent pas avec d'autres variables définies dans la même liste de paramètres, et que nous n'obtenons qu'une seule liste de paramètres implicites, nous devons recourir à un peu de ruse pour curry les paramètres de type:

val m = ObjectToMap(myDoc)
println(m) //Map('code -> ABCD, 'name -> Name(Roger,Rabbit), 'idx -> 12)

Lorsque nous exécutons la sortie du bloc précédent, nous obtenons:

import shapeless._

def ObjectToMap[A, Repr <: HList](obj: A)(
  implicit
  gen: LabelledGeneric.Aux[A,Repr], //Convert to generic representation
  toMap: ops.record.ToMap[Repr] //Convert generic representation to Map[Symbol,_]
) = toMap(gen.to(obj))

type nameT = nameType.type est incorrect. nameType.type est le type (singleton) de cette variable spécifique nameType et vous voulez le type de champ name . Cela a accidentellement fonctionné car en fait, vous n'utilisez pas T dans fromMap2 ( runtimeMirror (classTag [T] .runtimeClass.getClassLoader) peut être remplacé par currentMirror ici).

Vous vouliez appeler votre fromMap d'origine dans fromMapToObject . Vous connaissez universe.Type de nom et il suffit de trouver TypeTag et ClassTag paramètres implicites pour fromMap . Mais il ne suffit pas de trouver T . Le fait est que puisque vous utilisez la réflexion à l'exécution, vous connaissez universe.Type (et TypeTag , ClassTag ) au moment de l'exécution. Mais pour appeler fromMap , vous devez connaître T au moment de la compilation. Une façon est donc de utiliser la réflexion au moment de la compilation, c'est-à-dire des macros. Une autre façon est d'éviter T et d'utiliser des paramètres de valeur comme vous l'avez fait.