itération sur le cas de la classe de données des membres

Je suis en train d'écrire une play2.1 application avec mongodb, et mon modèle d'objet est un peu vaste. lors de la mise à jour d'une entrée dans la base de données, j'ai besoin de comparer la température de l'objet à venir à partir de la forme avec ce qui est dans la DB, donc je peux construire la requête de mise à jour (et enregistrer les modifications).

je suis à la recherche d'un moyen de génériquement prendre 2 instances et obtenir un diff. itération sur chaque membre de données est longue, codée en dur et sujettes à erreur (si un.prénom.equalsIgnoreCase(b.prenom)) donc je suis à la recherche d'un moyen pour itérer sur tous les membres de données et de les comparer à l'horizontale (une carte de nom -> valeur de la faire, ou une liste que je peux faire confiance à énumérer les membres de données dans le même ordre à chaque fois).

des idées?

case class Customer(
  id: Option[BSONObjectID] = Some(BSONObjectID.generate),
  firstName: String,
  middleName: String,
  lastName: String,
  address: List[Address],
  phoneNumbers: List[PhoneNumber],
  email: String,
  creationTime: Option[DateTime] = Some(DateTime.now()),
  lastUpdateTime: Option[DateTime] = Some(DateTime.now())
)

tous les trois solutions ci-dessous sont grands, mais je ne peux toujours pas obtenir le nom du champ, à droite? cela signifie que je peux me connecter le changement, mais pas dans quel domaine il a touché...

Pourriez-vous poster quelques extraits de code? Vos classes de cas, des exemples de cas et le résultat que vous souhaitez réaliser?

OriginalL'auteur Ehud Kaldor | 2013-07-24

  1. 8

    Expansion sur @Malte_Schwerhoff réponse, vous pourriez potentiellement créer un récursif diff méthode qui, non seulement a généré l'index de différences, mais les mappé à la nouvelle valeur à l'indice - ou, dans le cas d'imbrication des types de Produits, une carte de la sous-Produit de différences:

    def diff(orig: Product, update: Product): Map[Int, Any] = {
  assert(orig != null && update != null, "Both products must be non-null")
  assert(orig.getClass == update.getClass, "Both products must be of the same class")

  val diffs = for (ix <- 0 until orig.productArity) yield {
    (orig.productElement(ix), update.productElement(ix)) match {
      case (s1: String, s2: String) if (!s1.equalsIgnoreCase(s2)) => Some((ix -> s2))
      case (s1: String, s2: String) => None
      case (p1: Product, p2: Product) if (p1 != p2) => Some((ix -> diff(p1, p2)))
      case (x, y) if (x != y) => Some((ix -> y))
      case _ => None
    }
  }

  diffs.flatten.toMap
}

    Étendre sur le cas d'utilisation de cette réponse:

    case class A(x: Int, y: String)
case class B(a: A, b: AnyRef, c: Any)

val a1 = A(4, "four")
val a2 = A(4, "Four")
val a3 = A(4, "quatre")
val a4 = A(5, "five")
val b1 = B(a1, null, 6)
val b2 = B(a1, null, 7)
val b3 = B(a2, a2, a2)
val b4 = B(a4, null, 8)

println(diff(a1, a2)) //Map()
println(diff(a1, a3)) //Map(0 -> 5)
println(diff(a1, a4)) //Map(0 -> 5, 1 -> five)

println(diff(b1, b2)) //Map(2 -> 7)
println(diff(b1, b3)) //Map(1 -> A(4,four), 2 -> A(4,four))
println(diff(b1, b4)) //Map(0 -> Map(0 -> 5, 1 -> five), 2 -> 8l

    OriginalL'auteur Shadowlands

  2. 26

    Peut-être productIterator est ce que tu voulais:

    scala> case class C(x: Int, y: String, z: Char)
defined class C

scala> val c1 = C(1, "2", 'c')
c1: C = C(1,2,c)

scala> c1.productIterator.toList
res1: List[Any] = List(1, 2, c)

    OriginalL'auteur Eastsun

  3. 5

    Vous pouvez utiliser le produit d'itérateur, et match sur les éléments si vous souhaitez utiliser non-standard de l'égalité comme String.equalsIgnoreCase.

    def compare(p1: Product, p2: Product): List[Int] = {
  assert(p1 != null && p2 != null, "Both products must be non-null")
  assert(p1.getClass == p2.getClass, "Both products must be of the same class")

  var idx = List[Int]()

  for (i <- 0 until p1.productArity) {
    val equal = (p1.productElement(i), p2.productElement(i)) match {
      case (s1: String, s2: String) => s1.equalsIgnoreCase(s2)
      case (x, y) => x == y
    }

    if (!equal) idx ::= i
  }

  idx.reverse
}

    Cas d'utilisation:

    case class A(x: Int, y: String)
case class B(a: A, b: AnyRef, c: Any)

val a1 = A(4, "four")
val a2 = A(4, "Four")
val a3 = A(5, "five")
val b1 = B(a1, null, 6)
val b2 = B(a1, null, 7)
val b3 = B(a2, a2, a2)

println(compare(a1, a2)) //List()
println(compare(a1, a3)) //List(0, 1)

println(compare(b1, b2)) //List(2)
println(compare(b2, b3)) //List(0, 1, 2)

//println(compare(a1, b1)) //assertion failed

    OriginalL'auteur Malte Schwerhoff