Fonction de chargement d'objet générique pour scala

Question

Je démarre sur une application Scala qui utilise Hibernate (JPA) à l'arrière. Pour charger un objet, j'utilise cette ligne de code:

val addr = s.load(classOf[Address], addr_id).asInstanceOf[Address]; 

Inutile de dire, c'est un peu douloureux. J'ai écrit une classe d'aide qui ressemble à ceci:

import org.hibernate.Session 

class DataLoader(s: Session) { 
    def loadAddress(id: Long): Address = { 
    return s.load(classOf[Address], id).asInstanceOf[Address]; 
    } 
    ... 
} 

Alors, maintenant, je peux le faire:

val dl = new DataLoader(s) 
val addr = dl loadAddress(addr_id) 

Voici la question: Comment puis-je écrire une méthode paramétrisé générique qui peut charger tout objet en utilisant ce même modèle? i.e.

val addr = dl load[Address](addr_id) 

(ou quelque chose dans ce sens.)

Je suis nouveau à Scala donc s'il vous plaît pardonnez ici c'est particulièrement hideux.

Answer 1

Ici, il est:

import org.hibernate.Session 
class DataLoader(s: Session) { 
    def load[A](id: Long)(implicit m: Manifest[A]): A = { 
    return s.load(m.erasure, id).asInstanceOf[A]; 
    } 
} 

EDIT - Ou, pour faire en sorte que toute erreur de coulée - à la suite de mise en veille prolongée retournant le mauvais objet - qui va se passer à l'intérieur load, comme ceci:

import org.hibernate.Session 
class DataLoader(s: Session) { 
    def load[A](id: Long)(implicit m: Manifest[A]): A = { 
    return m.erasure.asInstanceOf[Class[A]].cast(s.load(m.erasure, id)); 
    } 
} 

Sur Scala 2.8 vous pouvez également écrire comme ceci:

import org.hibernate.Session 
class DataLoader(s: Session) { 
    def load[A : Manifest](id: Long): A = { 
    return s.load(manifest[A].erasure, id).asInstanceOf[A]; 
    } 
} 

Vous pouvez combiner avec une session implicite et, comme l'a suggéré Chris:

def load[A](id: Long)(implicit m: Manifest[A], s: org.hibernate.Session): A = { 
    return s.load(m.erasure, id).asInstanceOf[A]; 
} 

Notez que vous ne pouvez pas combiner la notation de vue contextuel (A : Manifest) avec des paramètres implicites supplémentaires.

Answer 2

Une méthode serait de faire bénéficier de la méthode java.lang.Class.cast afin de faire quelque chose comme:

def load[A](clazz: Class[A], id: Long)(implicit s: Session) : A 
     = clazz.cast(s.load(clazz, id)) 

Ensuite, l'utilisation est comme suit:

implicit val s = ...//get hibernate session 
val addr = load(classOf[Address], 1) 

Ce n'est pas extrêmement différent de ce que vous avez déjà, mais pour accéder à l'instance class, vous devez le transmettre.

Je suis assez confiant que vous ne pouvez pas en toute sécurité faire ce que vous voulez avec Manifests parce qu'ils ne peuvent pas fournir les Class[Address] à paramétrisé compilation dont vous avez besoin pour que la distribution au travail (ils ne peuvent fournir l'effacement de Class[_]). Je ne vois pas d'autre mécanisme pour faire un casting d'une Manifest

Vous pouvez bien sûr utiliser asInstanceOf[A] au lieu de cast mais cela est effacé à la compilation de isInstanceOf[Object] et est donc inutile en termes de vérification de type compilation (et donc déconseillé).