, तार से सरल स्काला मामले कक्षाओं का निर्माण कड़ाई से बॉयलर-प्लेट के बिना

Question

मैं स्ट्रिंग्स (जैसे एक csv लाइन) से सरल स्काला मामले कक्षाएं प्रारंभ करने में संक्षिप्त कोड की तलाश:

case class Person(name: String, age: Double) 
case class Book(title: String, author: String, year: Int) 
case class Country(name: String, population: Int, area: Double) 

val amy = Creator.create[Person]("Amy,54.2") 
val fred = Creator.create[Person]("Fred,23") 
val hamlet = Creator.create[Book]("Hamlet,Shakespeare,1600") 
val finland = Creator.create[Country]("Finland,4500000,338424") 

सरल Creator यह करने के लिए वस्तु क्या है ? मैं स्कैला के बारे में बहुत अच्छा समाधान देखने से बहुत कुछ सीखूंगा।

(ध्यान दें कि साथी वस्तुओं Person, Book और Country नहीं मौजूद करने के लिए मजबूर किया जाना है। यही कारण है कि बॉयलर-प्लेट होगा चाहिए!)

Answer 1

मैं एक समाधान है कि के बारे में के रूप में सरल रूप में आप प्राप्त कर सकते हैं देने के लिए जा रहा हूँ प्रकार सुरक्षा (कोई क्रम अपवाद नहीं, कोई क्रम प्रतिबिंब, आदि) के बारे में कुछ उचित की कमी को देखते हुए सामान्य व्युत्पत्ति के लिए Shapeless का उपयोग कर:

import scala.util.Try 
import shapeless._ 

trait Creator[A] { def apply(s: String): Option[A] } 

object Creator { 
    def create[A](s: String)(implicit c: Creator[A]): Option[A] = c(s) 

    def instance[A](parse: String => Option[A]): Creator[A] = new Creator[A] { 
    def apply(s: String): Option[A] = parse(s) 
    } 

    implicit val stringCreate: Creator[String] = instance(Some(_)) 
    implicit val intCreate: Creator[Int] = instance(s => Try(s.toInt).toOption) 
    implicit val doubleCreate: Creator[Double] = 
    instance(s => Try(s.toDouble).toOption) 

    implicit val hnilCreator: Creator[HNil] = 
    instance(s => if (s.isEmpty) Some(HNil) else None) 

    private[this] val NextCell = "^([^,]+)(?:,(.+))?$".r 

    implicit def hconsCreate[H: Creator, T <: HList: Creator]: Creator[H :: T] = 
    instance { 
     case NextCell(cell, rest) => for { 
     h <- create[H](cell) 
     t <- create[T](Option(rest).getOrElse("")) 
     } yield h :: t 
     case _ => None 
    } 

    implicit def caseClassCreate[C, R <: HList](implicit 
    gen: Generic.Aux[C, R], 
    rc: Creator[R] 
): Creator[C] = instance(s => rc(s).map(gen.from)) 
} 

निर्दिष्ट बिल्कुल के रूप में (हालांकि नोट करें कि मान Option में लिपटे रहे हैं प्रतिनिधित्व करने के लिए इस काम तथ्य यह है कि टी वह आपरेशन को पार्स असफल हो सकता है):

scala> case class Person(name: String, age: Double) 
defined class Person 

scala> case class Book(title: String, author: String, year: Int) 
defined class Book 

scala> case class Country(name: String, population: Int, area: Double) 
defined class Country 

scala> val amy = Creator.create[Person]("Amy,54.2") 
amy: Option[Person] = Some(Person(Amy,54.2)) 

scala> val fred = Creator.create[Person]("Fred,23") 
fred: Option[Person] = Some(Person(Fred,23.0)) 

scala> val hamlet = Creator.create[Book]("Hamlet,Shakespeare,1600") 
hamlet: Option[Book] = Some(Book(Hamlet,Shakespeare,1600)) 

scala> val finland = Creator.create[Country]("Finland,4500000,338424") 
finland: Option[Country] = Some(Country(Finland,4500000,338424.0)) 

यहाँ Creator एक प्रकार वर्ग कि सबूत नहीं है कि हम किसी दिए गए प्रकार में एक स्ट्रिंग पार्स कर सकते हैं प्रदान करता है। हमें String, Int इत्यादि जैसे मूल प्रकारों के लिए स्पष्ट उदाहरण प्रदान करना होगा, लेकिन हम केस वर्गों के लिए जेनेरिक रूप से उदाहरण प्राप्त करने के लिए बेकार का उपयोग कर सकते हैं (मानते हैं कि हमारे पास उनके सभी सदस्य प्रकारों के लिए Creator उदाहरण हैं)।

Answer 2

object Creator { 
    def create[T: ClassTag](params: String): T = { 
    val ctor = implicitly[ClassTag[T]].runtimeClass.getConstructors.head 
    val types = ctor.getParameterTypes 

    val paramsArray = params.split(",").map(_.trim) 

    val paramsWithTypes = paramsArray zip types 

    val parameters = paramsWithTypes.map { 
     case (param, clas) => 
     clas.getName match { 
      case "int" => param.toInt.asInstanceOf[Object] // needed only for AnyVal types 
      case "double" => param.toDouble.asInstanceOf[Object] // needed only for AnyVal types 
      case _ => 
      val paramConstructor = clas.getConstructor(param.getClass) 
      paramConstructor.newInstance(param).asInstanceOf[Object] 
     } 

    } 

    val r = ctor.newInstance(parameters: _*) 
    r.asInstanceOf[T] 
    } 
}